/*
 * uCharts (R)
 * 高性能跨平台图表库，支持H5、APP、小程序（微信/支付宝/百度/头条/QQ/360/快手）、Vue、Taro等支持canvas的框架平台
 * Copyright (C) 2018-2022 QIUN (R) 秋云 https://www.ucharts.cn All rights reserved.
 * Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
 * 复制使用请保留本段注释，感谢支持开源！
 *
 * uCharts (R) 官方网站
 * https://www.uCharts.cn
 *
 * 开源地址:
 * https://gitee.com/uCharts/uCharts
 *
 * uni-app插件市场地址：
 * http://ext.dcloud.net.cn/plugin?id=271
 *
 */

'use strict'

var config = {
	version: 'v2.5.0-20230101',
	yAxisWidth: 15,
	xAxisHeight: 22,
	padding: [10, 10, 10, 10],
	rotate: false,
	fontSize: 13,
	fontColor: '#666666',
	dataPointShape: ['circle', 'circle', 'circle', 'circle'],
	color: [
		'#1890FF',
		'#91CB74',
		'#FAC858',
		'#EE6666',
		'#73C0DE',
		'#3CA272',
		'#FC8452',
		'#9A60B4',
		'#ea7ccc',
	],
	linearColor: [
		'#0EE2F8',
		'#2BDCA8',
		'#FA7D8D',
		'#EB88E2',
		'#2AE3A0',
		'#0EE2F8',
		'#EB88E2',
		'#6773E3',
		'#F78A85',
	],
	pieChartLinePadding: 15,
	pieChartTextPadding: 5,
	titleFontSize: 20,
	subtitleFontSize: 15,
	radarLabelTextMargin: 13,
}

var assign = function (target, ...varArgs) {
	if (target == null) {
		throw new TypeError(
			'[uCharts] Cannot convert undefined or null to object'
		)
	}
	if (!varArgs || varArgs.length <= 0) {
		return target
	}
	// 深度合并对象
	function deepAssign(obj1, obj2) {
		for (let key in obj2) {
			obj1[key] =
				obj1[key] && obj1[key].toString() === '[object Object]'
					? deepAssign(obj1[key], obj2[key])
					: (obj1[key] = obj2[key])
		}
		return obj1
	}
	varArgs.forEach((val) => {
		target = deepAssign(target, val)
	})
	return target
}

var util = {
	toFixed: function toFixed(num, limit) {
		limit = limit || 2
		if (this.isFloat(num)) {
			num = num.toFixed(limit)
		}
		return num
	},
	isFloat: function isFloat(num) {
		return num % 1 !== 0
	},
	approximatelyEqual: function approximatelyEqual(num1, num2) {
		return Math.abs(num1 - num2) < 1e-10
	},
	isSameSign: function isSameSign(num1, num2) {
		return (
			(Math.abs(num1) === num1 && Math.abs(num2) === num2) ||
			(Math.abs(num1) !== num1 && Math.abs(num2) !== num2)
		)
	},
	isSameXCoordinateArea: function isSameXCoordinateArea(p1, p2) {
		return this.isSameSign(p1.x, p2.x)
	},
	isCollision: function isCollision(obj1, obj2) {
		obj1.end = {}
		obj1.end.x = obj1.start.x + obj1.width
		obj1.end.y = obj1.start.y - obj1.height
		obj2.end = {}
		obj2.end.x = obj2.start.x + obj2.width
		obj2.end.y = obj2.start.y - obj2.height
		var flag =
			obj2.start.x > obj1.end.x ||
			obj2.end.x < obj1.start.x ||
			obj2.end.y > obj1.start.y ||
			obj2.start.y < obj1.end.y
		return !flag
	},
}

//兼容H5点击事件
function getH5Offset(e) {
	e.mp = {
		changedTouches: [],
	}
	e.mp.changedTouches.push({
		x: e.offsetX,
		y: e.offsetY,
	})
	return e
}

// hex 转 rgba
function hexToRgb(hexValue, opc) {
	var rgx = /^#?([a-f\d])([a-f\d])([a-f\d])$/i
	var hex = hexValue.replace(rgx, function (m, r, g, b) {
		return r + r + g + g + b + b
	})
	var rgb = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
	var r = parseInt(rgb[1], 16)
	var g = parseInt(rgb[2], 16)
	var b = parseInt(rgb[3], 16)
	return 'rgba(' + r + ',' + g + ',' + b + ',' + opc + ')'
}

function findRange(num, type, limit) {
	if (isNaN(num)) {
		throw new Error('[uCharts] series数据需为Number格式')
	}
	limit = limit || 10
	type = type ? type : 'upper'
	var multiple = 1
	while (limit < 1) {
		limit *= 10
		multiple *= 10
	}
	if (type === 'upper') {
		num = Math.ceil(num * multiple)
	} else {
		num = Math.floor(num * multiple)
	}
	while (num % limit !== 0) {
		if (type === 'upper') {
			if (num == num + 1) {
				//修复数据值过大num++无效的bug by 向日葵 @xrk_jy
				break
			}
			num++
		} else {
			num--
		}
	}
	return num / multiple
}

function calCandleMA(dayArr, nameArr, colorArr, kdata) {
	let seriesTemp = []
	for (let k = 0; k < dayArr.length; k++) {
		let seriesItem = {
			data: [],
			name: nameArr[k],
			color: colorArr[k],
		}
		for (let i = 0, len = kdata.length; i < len; i++) {
			if (i < dayArr[k]) {
				seriesItem.data.push(null)
				continue
			}
			let sum = 0
			for (let j = 0; j < dayArr[k]; j++) {
				sum += kdata[i - j][1]
			}
			seriesItem.data.push(+(sum / dayArr[k]).toFixed(3))
		}
		seriesTemp.push(seriesItem)
	}
	return seriesTemp
}

function calValidDistance(self, distance, chartData, config, opts) {
	var dataChartAreaWidth = opts.width - opts.area[1] - opts.area[3]
	var dataChartWidth =
		chartData.eachSpacing *
		(opts.chartData.xAxisData.xAxisPoints.length - 1)
	if (
		opts.type == 'mount' &&
		opts.extra &&
		opts.extra.mount &&
		opts.extra.mount.widthRatio &&
		opts.extra.mount.widthRatio > 1
	) {
		if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
		dataChartWidth +=
			(opts.extra.mount.widthRatio - 1) * chartData.eachSpacing
	}
	var validDistance = distance
	if (distance >= 0) {
		validDistance = 0
		self.uevent.trigger('scrollLeft')
		self.scrollOption.position = 'left'
		opts.xAxis.scrollPosition = 'left'
	} else if (Math.abs(distance) >= dataChartWidth - dataChartAreaWidth) {
		validDistance = dataChartAreaWidth - dataChartWidth
		self.uevent.trigger('scrollRight')
		self.scrollOption.position = 'right'
		opts.xAxis.scrollPosition = 'right'
	} else {
		self.scrollOption.position = distance
		opts.xAxis.scrollPosition = distance
	}
	return validDistance
}

function isInAngleRange(angle, startAngle, endAngle) {
	function adjust(angle) {
		while (angle < 0) {
			angle += 2 * Math.PI
		}
		while (angle > 2 * Math.PI) {
			angle -= 2 * Math.PI
		}
		return angle
	}
	angle = adjust(angle)
	startAngle = adjust(startAngle)
	endAngle = adjust(endAngle)
	if (startAngle > endAngle) {
		endAngle += 2 * Math.PI
		if (angle < startAngle) {
			angle += 2 * Math.PI
		}
	}
	return angle >= startAngle && angle <= endAngle
}

function createCurveControlPoints(points, i) {
	function isNotMiddlePoint(points, i) {
		if (points[i - 1] && points[i + 1]) {
			return (
				points[i].y >= Math.max(points[i - 1].y, points[i + 1].y) ||
				points[i].y <= Math.min(points[i - 1].y, points[i + 1].y)
			)
		} else {
			return false
		}
	}
	function isNotMiddlePointX(points, i) {
		if (points[i - 1] && points[i + 1]) {
			return (
				points[i].x >= Math.max(points[i - 1].x, points[i + 1].x) ||
				points[i].x <= Math.min(points[i - 1].x, points[i + 1].x)
			)
		} else {
			return false
		}
	}
	var a = 0.2
	var b = 0.2
	var pAx = null
	var pAy = null
	var pBx = null
	var pBy = null
	if (i < 1) {
		pAx = points[0].x + (points[1].x - points[0].x) * a
		pAy = points[0].y + (points[1].y - points[0].y) * a
	} else {
		pAx = points[i].x + (points[i + 1].x - points[i - 1].x) * a
		pAy = points[i].y + (points[i + 1].y - points[i - 1].y) * a
	}

	if (i > points.length - 3) {
		var last = points.length - 1
		pBx = points[last].x - (points[last].x - points[last - 1].x) * b
		pBy = points[last].y - (points[last].y - points[last - 1].y) * b
	} else {
		pBx = points[i + 1].x - (points[i + 2].x - points[i].x) * b
		pBy = points[i + 1].y - (points[i + 2].y - points[i].y) * b
	}
	if (isNotMiddlePoint(points, i + 1)) {
		pBy = points[i + 1].y
	}
	if (isNotMiddlePoint(points, i)) {
		pAy = points[i].y
	}
	if (isNotMiddlePointX(points, i + 1)) {
		pBx = points[i + 1].x
	}
	if (isNotMiddlePointX(points, i)) {
		pAx = points[i].x
	}
	if (
		pAy >= Math.max(points[i].y, points[i + 1].y) ||
		pAy <= Math.min(points[i].y, points[i + 1].y)
	) {
		pAy = points[i].y
	}
	if (
		pBy >= Math.max(points[i].y, points[i + 1].y) ||
		pBy <= Math.min(points[i].y, points[i + 1].y)
	) {
		pBy = points[i + 1].y
	}
	if (
		pAx >= Math.max(points[i].x, points[i + 1].x) ||
		pAx <= Math.min(points[i].x, points[i + 1].x)
	) {
		pAx = points[i].x
	}
	if (
		pBx >= Math.max(points[i].x, points[i + 1].x) ||
		pBx <= Math.min(points[i].x, points[i + 1].x)
	) {
		pBx = points[i + 1].x
	}
	return {
		ctrA: {
			x: pAx,
			y: pAy,
		},
		ctrB: {
			x: pBx,
			y: pBy,
		},
	}
}

function convertCoordinateOrigin(x, y, center) {
	return {
		x: center.x + x,
		y: center.y - y,
	}
}

function avoidCollision(obj, target) {
	if (target) {
		// is collision test
		while (util.isCollision(obj, target)) {
			if (obj.start.x > 0) {
				obj.start.y--
			} else if (obj.start.x < 0) {
				obj.start.y++
			} else {
				if (obj.start.y > 0) {
					obj.start.y++
				} else {
					obj.start.y--
				}
			}
		}
	}
	return obj
}

function fixPieSeries(series, opts, config) {
	let pieSeriesArr = []
	if (
		series.length > 0 &&
		series[0].data.constructor.toString().indexOf('Array') > -1
	) {
		opts._pieSeries_ = series
		let oldseries = series[0].data
		for (var i = 0; i < oldseries.length; i++) {
			oldseries[i].formatter = series[0].formatter
			oldseries[i].data = oldseries[i].value
			pieSeriesArr.push(oldseries[i])
		}
		opts.series = pieSeriesArr
	} else {
		pieSeriesArr = series
	}
	return pieSeriesArr
}

function fillSeries(series, opts, config) {
	var index = 0
	for (var i = 0; i < series.length; i++) {
		let item = series[i]
		if (!item.color) {
			item.color = config.color[index]
			index = (index + 1) % config.color.length
		}
		if (!item.linearIndex) {
			item.linearIndex = i
		}
		if (!item.index) {
			item.index = 0
		}
		if (!item.type) {
			item.type = opts.type
		}
		if (typeof item.show == 'undefined') {
			item.show = true
		}
		if (!item.type) {
			item.type = opts.type
		}
		if (!item.pointShape) {
			item.pointShape = 'circle'
		}
		if (!item.legendShape) {
			switch (item.type) {
				case 'line':
					item.legendShape = 'line'
					break
				case 'column':
				case 'bar':
					item.legendShape = 'rect'
					break
				case 'area':
				case 'mount':
					item.legendShape = 'triangle'
					break
				default:
					item.legendShape = 'circle'
			}
		}
	}
	return series
}

function fillCustomColor(linearType, customColor, series, config) {
	var newcolor = customColor || []
	if (linearType == 'custom' && newcolor.length == 0) {
		newcolor = config.linearColor
	}
	if (linearType == 'custom' && newcolor.length < series.length) {
		let chazhi = series.length - newcolor.length
		for (var i = 0; i < chazhi; i++) {
			newcolor.push(
				config.linearColor[(i + 1) % config.linearColor.length]
			)
		}
	}
	return newcolor
}

function getDataRange(minData, maxData) {
	var limit = 0
	var range = maxData - minData
	if (range >= 10000) {
		limit = 1000
	} else if (range >= 1000) {
		limit = 100
	} else if (range >= 100) {
		limit = 10
	} else if (range >= 10) {
		limit = 5
	} else if (range >= 1) {
		limit = 1
	} else if (range >= 0.1) {
		limit = 0.1
	} else if (range >= 0.01) {
		limit = 0.01
	} else if (range >= 0.001) {
		limit = 0.001
	} else if (range >= 0.0001) {
		limit = 0.0001
	} else if (range >= 0.00001) {
		limit = 0.00001
	} else {
		limit = 0.000001
	}
	return {
		minRange: findRange(minData, 'lower', limit),
		maxRange: findRange(maxData, 'upper', limit),
	}
}

function measureText(text, fontSize, context) {
	var width = 0
	text = String(text)
	// #ifdef MP-ALIPAY || MP-BAIDU || APP-NVUE
	context = false
	// #endif
	if (
		context !== false &&
		context !== undefined &&
		context.setFontSize &&
		context.measureText
	) {
		context.setFontSize(fontSize)
		return context.measureText(text).width
	} else {
		var text = text.split('')
		for (let i = 0; i < text.length; i++) {
			let item = text[i]
			if (/[a-zA-Z]/.test(item)) {
				width += 7
			} else if (/[0-9]/.test(item)) {
				width += 5.5
			} else if (/\./.test(item)) {
				width += 2.7
			} else if (/-/.test(item)) {
				width += 3.25
			} else if (/:/.test(item)) {
				width += 2.5
			} else if (/[\u4e00-\u9fa5]/.test(item)) {
				width += 10
			} else if (/\(|\)/.test(item)) {
				width += 3.73
			} else if (/\s/.test(item)) {
				width += 2.5
			} else if (/%/.test(item)) {
				width += 8
			} else {
				width += 10
			}
		}
		return (width * fontSize) / 10
	}
}

function dataCombine(series) {
	return series.reduce(function (a, b) {
		return (a.data ? a.data : a).concat(b.data)
	}, [])
}

function dataCombineStack(series, len) {
	var sum = new Array(len)
	for (var j = 0; j < sum.length; j++) {
		sum[j] = 0
	}
	for (var i = 0; i < series.length; i++) {
		for (var j = 0; j < sum.length; j++) {
			sum[j] += series[i].data[j]
		}
	}
	return series.reduce(function (a, b) {
		return (a.data ? a.data : a).concat(b.data).concat(sum)
	}, [])
}

function getTouches(touches, opts, e) {
	let x, y
	if (touches.clientX) {
		if (opts.rotate) {
			y = opts.height - touches.clientX * opts.pix
			x =
				(touches.pageY -
					e.currentTarget.offsetTop -
					(opts.height / opts.pix / 2) * (opts.pix - 1)) *
				opts.pix
		} else {
			x = touches.clientX * opts.pix
			y =
				(touches.pageY -
					e.currentTarget.offsetTop -
					(opts.height / opts.pix / 2) * (opts.pix - 1)) *
				opts.pix
		}
	} else {
		if (opts.rotate) {
			y = opts.height - touches.x * opts.pix
			x = touches.y * opts.pix
		} else {
			x = touches.x * opts.pix
			y = touches.y * opts.pix
		}
	}
	return {
		x: x,
		y: y,
	}
}

function getSeriesDataItem(series, index, group) {
	var data = []
	var newSeries = []
	var indexIsArr = index.constructor.toString().indexOf('Array') > -1
	if (indexIsArr) {
		let tempSeries = filterSeries(series)
		for (var i = 0; i < group.length; i++) {
			newSeries.push(tempSeries[group[i]])
		}
	} else {
		newSeries = series
	}
	for (let i = 0; i < newSeries.length; i++) {
		let item = newSeries[i]
		let tmpindex = -1
		if (indexIsArr) {
			tmpindex = index[i]
		} else {
			tmpindex = index
		}
		if (
			item.data[tmpindex] !== null &&
			typeof item.data[tmpindex] !== 'undefined' &&
			item.show
		) {
			let seriesItem = {}
			seriesItem.color = item.color
			seriesItem.type = item.type
			seriesItem.style = item.style
			seriesItem.pointShape = item.pointShape
			seriesItem.disableLegend = item.disableLegend
			seriesItem.legendShape = item.legendShape
			seriesItem.name = item.name
			seriesItem.show = item.show
			seriesItem.data = item.formatter
				? item.formatter(item.data[tmpindex])
				: item.data[tmpindex]
			data.push(seriesItem)
		}
	}
	return data
}

function getMaxTextListLength(list, fontSize, context) {
	var lengthList = list.map(function (item) {
		return measureText(item, fontSize, context)
	})
	return Math.max.apply(null, lengthList)
}

function getRadarCoordinateSeries(length) {
	var eachAngle = (2 * Math.PI) / length
	var CoordinateSeries = []
	for (var i = 0; i < length; i++) {
		CoordinateSeries.push(eachAngle * i)
	}
	return CoordinateSeries.map(function (item) {
		return -1 * item + Math.PI / 2
	})
}

function getToolTipData(seriesData, opts, index, group, categories) {
	var option =
		arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : {}
	var calPoints = opts.chartData.calPoints ? opts.chartData.calPoints : []
	let points = {}
	if (group.length > 0) {
		let filterPoints = []
		for (let i = 0; i < group.length; i++) {
			filterPoints.push(calPoints[group[i]])
		}
		points = filterPoints[0][index[0]]
	} else {
		for (let i = 0; i < calPoints.length; i++) {
			if (calPoints[i][index]) {
				points = calPoints[i][index]
				break
			}
		}
	}
	var textList = seriesData.map(function (item) {
		let titleText = null
		if (opts.categories && opts.categories.length > 0) {
			titleText = categories[index]
		}
		return {
			text: option.formatter
				? option.formatter(item, titleText, index, opts)
				: item.name + ': ' + item.data,
			color: item.color,
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
	})
	var offset = {
		x: Math.round(points.x),
		y: Math.round(points.y),
	}
	return {
		textList: textList,
		offset: offset,
	}
}

function getMixToolTipData(seriesData, opts, index, categories) {
	var option =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {}
	var points =
		opts.chartData.xAxisPoints[index] + opts.chartData.eachSpacing / 2
	var textList = seriesData.map(function (item) {
		return {
			text: option.formatter
				? option.formatter(item, categories[index], index, opts)
				: item.name + ': ' + item.data,
			color: item.color,
			disableLegend: item.disableLegend ? true : false,
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
	})
	textList = textList.filter(function (item) {
		if (item.disableLegend !== true) {
			return item
		}
	})
	var offset = {
		x: Math.round(points),
		y: 0,
	}
	return {
		textList: textList,
		offset: offset,
	}
}

function getCandleToolTipData(
	series,
	seriesData,
	opts,
	index,
	categories,
	extra
) {
	var option =
		arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : {}
	var calPoints = opts.chartData.calPoints
	let upColor = extra.color.upFill
	let downColor = extra.color.downFill
	//颜色顺序为开盘，收盘，最低，最高
	let color = [upColor, upColor, downColor, upColor]
	var textList = []
	seriesData.map(function (item) {
		if (index == 0) {
			if (item.data[1] - item.data[0] < 0) {
				color[1] = downColor
			} else {
				color[1] = upColor
			}
		} else {
			if (item.data[0] < series[index - 1][1]) {
				color[0] = downColor
			}
			if (item.data[1] < item.data[0]) {
				color[1] = downColor
			}
			if (item.data[2] > series[index - 1][1]) {
				color[2] = upColor
			}
			if (item.data[3] < series[index - 1][1]) {
				color[3] = downColor
			}
		}
		let text1 = {
			text: '开盘：' + item.data[0],
			color: color[0],
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
		let text2 = {
			text: '收盘：' + item.data[1],
			color: color[1],
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
		let text3 = {
			text: '最低：' + item.data[2],
			color: color[2],
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
		let text4 = {
			text: '最高：' + item.data[3],
			color: color[3],
			legendShape:
				opts.extra.tooltip.legendShape == 'auto'
					? item.legendShape
					: opts.extra.tooltip.legendShape,
		}
		textList.push(text1, text2, text3, text4)
	})
	var validCalPoints = []
	var offset = {
		x: 0,
		y: 0,
	}
	for (let i = 0; i < calPoints.length; i++) {
		let points = calPoints[i]
		if (typeof points[index] !== 'undefined' && points[index] !== null) {
			validCalPoints.push(points[index])
		}
	}
	offset.x = Math.round(validCalPoints[0][0].x)
	return {
		textList: textList,
		offset: offset,
	}
}

function filterSeries(series) {
	let tempSeries = []
	for (let i = 0; i < series.length; i++) {
		if (series[i].show == true) {
			tempSeries.push(series[i])
		}
	}
	return tempSeries
}

function findCurrentIndex(currentPoints, calPoints, opts, config) {
	var offset =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0
	var current = { index: -1, group: [] }
	var spacing = opts.chartData.eachSpacing / 2
	let xAxisPoints = []
	if (calPoints && calPoints.length > 0) {
		if (!opts.categories) {
			spacing = 0
		} else {
			for (let i = 1; i < opts.chartData.xAxisPoints.length; i++) {
				xAxisPoints.push(opts.chartData.xAxisPoints[i] - spacing)
			}
			if (
				(opts.type == 'line' || opts.type == 'area') &&
				opts.xAxis.boundaryGap == 'justify'
			) {
				xAxisPoints = opts.chartData.xAxisPoints
			}
		}
		if (isInExactChartArea(currentPoints, opts, config)) {
			if (!opts.categories) {
				let timePoints = Array(calPoints.length)
				for (let i = 0; i < calPoints.length; i++) {
					timePoints[i] = Array(calPoints[i].length)
					for (let j = 0; j < calPoints[i].length; j++) {
						timePoints[i][j] = Math.abs(
							calPoints[i][j].x - currentPoints.x
						)
					}
				}
				let pointValue = Array(timePoints.length)
				let pointIndex = Array(timePoints.length)
				for (let i = 0; i < timePoints.length; i++) {
					pointValue[i] = Math.min.apply(null, timePoints[i])
					pointIndex[i] = timePoints[i].indexOf(pointValue[i])
				}
				let minValue = Math.min.apply(null, pointValue)
				current.index = []
				for (let i = 0; i < pointValue.length; i++) {
					if (pointValue[i] == minValue) {
						current.group.push(i)
						current.index.push(pointIndex[i])
					}
				}
			} else {
				xAxisPoints.forEach(function (item, index) {
					if (currentPoints.x + offset + spacing > item) {
						current.index = index
					}
				})
			}
		}
	}
	return current
}

function findBarChartCurrentIndex(currentPoints, calPoints, opts, config) {
	var offset =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0
	var current = { index: -1, group: [] }
	var spacing = opts.chartData.eachSpacing / 2
	let yAxisPoints = opts.chartData.yAxisPoints
	if (calPoints && calPoints.length > 0) {
		if (isInExactChartArea(currentPoints, opts, config)) {
			yAxisPoints.forEach(function (item, index) {
				if (currentPoints.y + offset + spacing > item) {
					current.index = index
				}
			})
		}
	}
	return current
}

function findLegendIndex(currentPoints, legendData, opts) {
	let currentIndex = -1
	let gap = 0
	if (isInExactLegendArea(currentPoints, legendData.area)) {
		let points = legendData.points
		let index = -1
		for (let i = 0, len = points.length; i < len; i++) {
			let item = points[i]
			for (let j = 0; j < item.length; j++) {
				index += 1
				let area = item[j]['area']
				if (
					area &&
					currentPoints.x > area[0] - gap &&
					currentPoints.x < area[2] + gap &&
					currentPoints.y > area[1] - gap &&
					currentPoints.y < area[3] + gap
				) {
					currentIndex = index
					break
				}
			}
		}
		return currentIndex
	}
	return currentIndex
}

function isInExactLegendArea(currentPoints, area) {
	return (
		currentPoints.x > area.start.x &&
		currentPoints.x < area.end.x &&
		currentPoints.y > area.start.y &&
		currentPoints.y < area.end.y
	)
}

function isInExactChartArea(currentPoints, opts, config) {
	return (
		currentPoints.x <= opts.width - opts.area[1] + 10 &&
		currentPoints.x >= opts.area[3] - 10 &&
		currentPoints.y >= opts.area[0] &&
		currentPoints.y <= opts.height - opts.area[2]
	)
}

function findRadarChartCurrentIndex(currentPoints, radarData, count) {
	var eachAngleArea = (2 * Math.PI) / count
	var currentIndex = -1
	if (
		isInExactPieChartArea(currentPoints, radarData.center, radarData.radius)
	) {
		var fixAngle = function fixAngle(angle) {
			if (angle < 0) {
				angle += 2 * Math.PI
			}
			if (angle > 2 * Math.PI) {
				angle -= 2 * Math.PI
			}
			return angle
		}
		var angle = Math.atan2(
			radarData.center.y - currentPoints.y,
			currentPoints.x - radarData.center.x
		)
		angle = -1 * angle
		if (angle < 0) {
			angle += 2 * Math.PI
		}
		var angleList = radarData.angleList.map(function (item) {
			item = fixAngle(-1 * item)
			return item
		})
		angleList.forEach(function (item, index) {
			var rangeStart = fixAngle(item - eachAngleArea / 2)
			var rangeEnd = fixAngle(item + eachAngleArea / 2)
			if (rangeEnd < rangeStart) {
				rangeEnd += 2 * Math.PI
			}
			if (
				(angle >= rangeStart && angle <= rangeEnd) ||
				(angle + 2 * Math.PI >= rangeStart &&
					angle + 2 * Math.PI <= rangeEnd)
			) {
				currentIndex = index
			}
		})
	}
	return currentIndex
}

function findFunnelChartCurrentIndex(currentPoints, funnelData) {
	var currentIndex = -1
	for (var i = 0, len = funnelData.series.length; i < len; i++) {
		var item = funnelData.series[i]
		if (
			currentPoints.x > item.funnelArea[0] &&
			currentPoints.x < item.funnelArea[2] &&
			currentPoints.y > item.funnelArea[1] &&
			currentPoints.y < item.funnelArea[3]
		) {
			currentIndex = i
			break
		}
	}
	return currentIndex
}

function findWordChartCurrentIndex(currentPoints, wordData) {
	var currentIndex = -1
	for (var i = 0, len = wordData.length; i < len; i++) {
		var item = wordData[i]
		if (
			currentPoints.x > item.area[0] &&
			currentPoints.x < item.area[2] &&
			currentPoints.y > item.area[1] &&
			currentPoints.y < item.area[3]
		) {
			currentIndex = i
			break
		}
	}
	return currentIndex
}

function findMapChartCurrentIndex(currentPoints, opts) {
	var currentIndex = -1
	var cData = opts.chartData.mapData
	var data = opts.series
	var tmp = pointToCoordinate(
		currentPoints.y,
		currentPoints.x,
		cData.bounds,
		cData.scale,
		cData.xoffset,
		cData.yoffset
	)
	var poi = [tmp.x, tmp.y]
	for (var i = 0, len = data.length; i < len; i++) {
		var item = data[i].geometry.coordinates
		if (isPoiWithinPoly(poi, item, opts.chartData.mapData.mercator)) {
			currentIndex = i
			break
		}
	}
	return currentIndex
}

function findRoseChartCurrentIndex(currentPoints, pieData, opts) {
	var currentIndex = -1
	var series = getRoseDataPoints(
		opts._series_,
		opts.extra.rose.type,
		pieData.radius,
		pieData.radius
	)
	if (
		pieData &&
		pieData.center &&
		isInExactPieChartArea(currentPoints, pieData.center, pieData.radius)
	) {
		var angle = Math.atan2(
			pieData.center.y - currentPoints.y,
			currentPoints.x - pieData.center.x
		)
		angle = -angle
		if (opts.extra.rose && opts.extra.rose.offsetAngle) {
			angle = angle - (opts.extra.rose.offsetAngle * Math.PI) / 180
		}
		for (var i = 0, len = series.length; i < len; i++) {
			if (
				isInAngleRange(
					angle,
					series[i]._start_,
					series[i]._start_ +
						series[i]._rose_proportion_ * 2 * Math.PI
				)
			) {
				currentIndex = i
				break
			}
		}
	}
	return currentIndex
}

function findPieChartCurrentIndex(currentPoints, pieData, opts) {
	var currentIndex = -1
	var series = getPieDataPoints(pieData.series)
	if (
		pieData &&
		pieData.center &&
		isInExactPieChartArea(currentPoints, pieData.center, pieData.radius)
	) {
		var angle = Math.atan2(
			pieData.center.y - currentPoints.y,
			currentPoints.x - pieData.center.x
		)
		angle = -angle
		if (opts.extra.pie && opts.extra.pie.offsetAngle) {
			angle = angle - (opts.extra.pie.offsetAngle * Math.PI) / 180
		}
		if (opts.extra.ring && opts.extra.ring.offsetAngle) {
			angle = angle - (opts.extra.ring.offsetAngle * Math.PI) / 180
		}
		for (var i = 0, len = series.length; i < len; i++) {
			if (
				isInAngleRange(
					angle,
					series[i]._start_,
					series[i]._start_ + series[i]._proportion_ * 2 * Math.PI
				)
			) {
				currentIndex = i
				break
			}
		}
	}
	return currentIndex
}

function isInExactPieChartArea(currentPoints, center, radius) {
	return (
		Math.pow(currentPoints.x - center.x, 2) +
			Math.pow(currentPoints.y - center.y, 2) <=
		Math.pow(radius, 2)
	)
}

function splitPoints(points, eachSeries) {
	var newPoints = []
	var items = []
	points.forEach(function (item, index) {
		if (eachSeries.connectNulls) {
			if (item !== null) {
				items.push(item)
			}
		} else {
			if (item !== null) {
				items.push(item)
			} else {
				if (items.length) {
					newPoints.push(items)
				}
				items = []
			}
		}
	})
	if (items.length) {
		newPoints.push(items)
	}
	return newPoints
}

function calLegendData(series, opts, config, chartData, context) {
	let legendData = {
		area: {
			start: {
				x: 0,
				y: 0,
			},
			end: {
				x: 0,
				y: 0,
			},
			width: 0,
			height: 0,
			wholeWidth: 0,
			wholeHeight: 0,
		},
		points: [],
		widthArr: [],
		heightArr: [],
	}
	if (opts.legend.show === false) {
		chartData.legendData = legendData
		return legendData
	}
	let padding = opts.legend.padding * opts.pix
	let margin = opts.legend.margin * opts.pix
	let fontSize = opts.legend.fontSize
		? opts.legend.fontSize * opts.pix
		: config.fontSize
	let shapeWidth = 15 * opts.pix
	let shapeRight = 5 * opts.pix
	let lineHeight = Math.max(opts.legend.lineHeight * opts.pix, fontSize)
	if (opts.legend.position == 'top' || opts.legend.position == 'bottom') {
		let legendList = []
		let widthCount = 0
		let widthCountArr = []
		let currentRow = []
		for (let i = 0; i < series.length; i++) {
			let item = series[i]
			const legendText = item.legendText ? item.legendText : item.name
			let itemWidth =
				shapeWidth +
				shapeRight +
				measureText(legendText || 'undefined', fontSize, context) +
				opts.legend.itemGap * opts.pix
			if (
				widthCount + itemWidth >
				opts.width - opts.area[1] - opts.area[3]
			) {
				legendList.push(currentRow)
				widthCountArr.push(widthCount - opts.legend.itemGap * opts.pix)
				widthCount = itemWidth
				currentRow = [item]
			} else {
				widthCount += itemWidth
				currentRow.push(item)
			}
		}
		if (currentRow.length) {
			legendList.push(currentRow)
			widthCountArr.push(widthCount - opts.legend.itemGap * opts.pix)
			legendData.widthArr = widthCountArr
			let legendWidth = Math.max.apply(null, widthCountArr)
			switch (opts.legend.float) {
				case 'left':
					legendData.area.start.x = opts.area[3]
					legendData.area.end.x =
						opts.area[3] + legendWidth + 2 * padding
					break
				case 'right':
					legendData.area.start.x =
						opts.width - opts.area[1] - legendWidth - 2 * padding
					legendData.area.end.x = opts.width - opts.area[1]
					break
				default:
					legendData.area.start.x =
						(opts.width - legendWidth) / 2 - padding
					legendData.area.end.x =
						(opts.width + legendWidth) / 2 + padding
			}
			legendData.area.width = legendWidth + 2 * padding
			legendData.area.wholeWidth = legendWidth + 2 * padding
			legendData.area.height =
				legendList.length * lineHeight + 2 * padding
			legendData.area.wholeHeight =
				legendList.length * lineHeight + 2 * padding + 2 * margin
			legendData.points = legendList
		}
	} else {
		let len = series.length
		let maxHeight =
			opts.height - opts.area[0] - opts.area[2] - 2 * margin - 2 * padding
		let maxLength = Math.min(Math.floor(maxHeight / lineHeight), len)
		legendData.area.height = maxLength * lineHeight + padding * 2
		legendData.area.wholeHeight = maxLength * lineHeight + padding * 2
		switch (opts.legend.float) {
			case 'top':
				legendData.area.start.y = opts.area[0] + margin
				legendData.area.end.y =
					opts.area[0] + margin + legendData.area.height
				break
			case 'bottom':
				legendData.area.start.y =
					opts.height - opts.area[2] - margin - legendData.area.height
				legendData.area.end.y = opts.height - opts.area[2] - margin
				break
			default:
				legendData.area.start.y =
					(opts.height - legendData.area.height) / 2
				legendData.area.end.y =
					(opts.height + legendData.area.height) / 2
		}
		let lineNum =
			len % maxLength === 0
				? len / maxLength
				: Math.floor(len / maxLength + 1)
		let currentRow = []
		for (let i = 0; i < lineNum; i++) {
			let temp = series.slice(i * maxLength, i * maxLength + maxLength)
			currentRow.push(temp)
		}
		legendData.points = currentRow
		if (currentRow.length) {
			for (let i = 0; i < currentRow.length; i++) {
				let item = currentRow[i]
				let maxWidth = 0
				for (let j = 0; j < item.length; j++) {
					let itemWidth =
						shapeWidth +
						shapeRight +
						measureText(
							item[j].name || 'undefined',
							fontSize,
							context
						) +
						opts.legend.itemGap * opts.pix
					if (itemWidth > maxWidth) {
						maxWidth = itemWidth
					}
				}
				legendData.widthArr.push(maxWidth)
				legendData.heightArr.push(
					item.length * lineHeight + padding * 2
				)
			}
			let legendWidth = 0
			for (let i = 0; i < legendData.widthArr.length; i++) {
				legendWidth += legendData.widthArr[i]
			}
			legendData.area.width =
				legendWidth - opts.legend.itemGap * opts.pix + 2 * padding
			legendData.area.wholeWidth = legendData.area.width + padding
		}
	}
	switch (opts.legend.position) {
		case 'top':
			legendData.area.start.y = opts.area[0] + margin
			legendData.area.end.y =
				opts.area[0] + margin + legendData.area.height
			break
		case 'bottom':
			legendData.area.start.y =
				opts.height - opts.area[2] - legendData.area.height - margin
			legendData.area.end.y = opts.height - opts.area[2] - margin
			break
		case 'left':
			legendData.area.start.x = opts.area[3]
			legendData.area.end.x = opts.area[3] + legendData.area.width
			break
		case 'right':
			legendData.area.start.x =
				opts.width - opts.area[1] - legendData.area.width
			legendData.area.end.x = opts.width - opts.area[1]
			break
	}
	chartData.legendData = legendData
	return legendData
}

function calCategoriesData(categories, opts, config, eachSpacing, context) {
	var result = {
		angle: 0,
		xAxisHeight:
			opts.xAxis.lineHeight * opts.pix + opts.xAxis.marginTop * opts.pix,
	}
	var fontSize = opts.xAxis.fontSize * opts.pix
	var categoriesTextLenth = categories.map(function (item, index) {
		var xitem = opts.xAxis.formatter
			? opts.xAxis.formatter(item, index, opts)
			: item
		return measureText(String(xitem), fontSize, context)
	})
	var maxTextLength = Math.max.apply(this, categoriesTextLenth)
	if (opts.xAxis.rotateLabel == true) {
		result.angle = (opts.xAxis.rotateAngle * Math.PI) / 180
		let tempHeight =
			opts.xAxis.marginTop * opts.pix * 2 +
			Math.abs(maxTextLength * Math.sin(result.angle))
		tempHeight =
			tempHeight < fontSize + opts.xAxis.marginTop * opts.pix * 2
				? tempHeight + opts.xAxis.marginTop * opts.pix * 2
				: tempHeight
		result.xAxisHeight = tempHeight
	}
	if (opts.enableScroll && opts.xAxis.scrollShow) {
		result.xAxisHeight += 6 * opts.pix
	}
	if (opts.xAxis.disabled) {
		result.xAxisHeight = 0
	}
	return result
}

function getXAxisTextList(series, opts, config, stack) {
	var index =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1
	var data
	if (stack == 'stack') {
		data = dataCombineStack(series, opts.categories.length)
	} else {
		data = dataCombine(series)
	}
	var sorted = []
	// remove null from data
	data = data.filter(function (item) {
		//return item !== null;
		if (typeof item === 'object' && item !== null) {
			if (item.constructor.toString().indexOf('Array') > -1) {
				return item !== null
			} else {
				return item.value !== null
			}
		} else {
			return item !== null
		}
	})
	data.map(function (item) {
		if (typeof item === 'object') {
			if (item.constructor.toString().indexOf('Array') > -1) {
				if (opts.type == 'candle') {
					item.map(function (subitem) {
						sorted.push(subitem)
					})
				} else {
					sorted.push(item[0])
				}
			} else {
				sorted.push(item.value)
			}
		} else {
			sorted.push(item)
		}
	})

	var minData = 0
	var maxData = 0
	if (sorted.length > 0) {
		minData = Math.min.apply(this, sorted)
		maxData = Math.max.apply(this, sorted)
	}
	//为了兼容v1.9.0之前的项目
	if (index > -1) {
		if (typeof opts.xAxis.data[index].min === 'number') {
			minData = Math.min(opts.xAxis.data[index].min, minData)
		}
		if (typeof opts.xAxis.data[index].max === 'number') {
			maxData = Math.max(opts.xAxis.data[index].max, maxData)
		}
	} else {
		if (typeof opts.xAxis.min === 'number') {
			minData = Math.min(opts.xAxis.min, minData)
		}
		if (typeof opts.xAxis.max === 'number') {
			maxData = Math.max(opts.xAxis.max, maxData)
		}
	}
	if (minData === maxData) {
		var rangeSpan = maxData || 10
		maxData += rangeSpan
	}
	//var dataRange = getDataRange(minData, maxData);
	var minRange = minData
	var maxRange = maxData
	var range = []
	var eachRange = (maxRange - minRange) / opts.xAxis.splitNumber
	for (var i = 0; i <= opts.xAxis.splitNumber; i++) {
		range.push(minRange + eachRange * i)
	}
	return range
}

function calXAxisData(series, opts, config, context) {
	//堆叠图重算Y轴
	var columnstyle = assign(
		{},
		{
			type: '',
		},
		opts.extra.bar
	)
	var result = {
		angle: 0,
		xAxisHeight:
			opts.xAxis.lineHeight * opts.pix + opts.xAxis.marginTop * opts.pix,
	}
	result.ranges = getXAxisTextList(series, opts, config, columnstyle.type)
	result.rangesFormat = result.ranges.map(function (item) {
		//item = opts.xAxis.formatter ? opts.xAxis.formatter(item) : util.toFixed(item, 2);
		item = util.toFixed(item, 2)
		return item
	})
	var xAxisScaleValues = result.ranges.map(function (item) {
		// 如果刻度值是浮点数,则保留两位小数
		item = util.toFixed(item, 2)
		// 若有自定义格式则调用自定义的格式化函数
		//item = opts.xAxis.formatter ? opts.xAxis.formatter(Number(item)) : item;
		return item
	})
	result = Object.assign(
		result,
		getXAxisPoints(xAxisScaleValues, opts, config)
	)
	// 计算X轴刻度的属性譬如每个刻度的间隔,刻度的起始点\结束点以及总长
	var eachSpacing = result.eachSpacing
	var textLength = xAxisScaleValues.map(function (item) {
		return measureText(item, opts.xAxis.fontSize * opts.pix, context)
	})
	if (opts.xAxis.disabled === true) {
		result.xAxisHeight = 0
	}
	return result
}

function getRadarDataPoints(angleList, center, radius, series, opts) {
	var process =
		arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
	var radarOption = opts.extra.radar || {}
	radarOption.max = radarOption.max || 0
	var maxData = Math.max(
		radarOption.max,
		Math.max.apply(null, dataCombine(series))
	)
	var data = []
	for (let i = 0; i < series.length; i++) {
		let each = series[i]
		let listItem = {}
		listItem.color = each.color
		listItem.legendShape = each.legendShape
		listItem.pointShape = each.pointShape
		listItem.data = []
		each.data.forEach(function (item, index) {
			let tmp = {}
			tmp.angle = angleList[index]
			tmp.proportion = item / maxData
			tmp.value = item
			tmp.position = convertCoordinateOrigin(
				radius * tmp.proportion * process * Math.cos(tmp.angle),
				radius * tmp.proportion * process * Math.sin(tmp.angle),
				center
			)
			listItem.data.push(tmp)
		})
		data.push(listItem)
	}
	return data
}

function getPieDataPoints(series, radius) {
	var process =
		arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
	var count = 0
	var _start_ = 0
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		count += item.data
	}
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		if (count === 0) {
			item._proportion_ = (1 / series.length) * process
		} else {
			item._proportion_ = (item.data / count) * process
		}
		item._radius_ = radius
	}
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item._start_ = _start_
		_start_ += 2 * item._proportion_ * Math.PI
	}
	return series
}

function getFunnelDataPoints(series, radius, option, eachSpacing) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	for (let i = 0; i < series.length; i++) {
		if (option.type == 'funnel') {
			series[i].radius =
				(series[i].data / series[0].data) * radius * process
		} else {
			series[i].radius =
				((eachSpacing * (series.length - i)) /
					(eachSpacing * series.length)) *
				radius *
				process
		}
		series[i]._proportion_ = series[i].data / series[0].data
	}
	// if(option.type !== 'pyramid'){
	//   series.reverse();
	// }
	return series
}

function getRoseDataPoints(series, type, minRadius, radius) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var count = 0
	var _start_ = 0
	var dataArr = []
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		count += item.data
		dataArr.push(item.data)
	}
	var minData = Math.min.apply(null, dataArr)
	var maxData = Math.max.apply(null, dataArr)
	var radiusLength = radius - minRadius
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		if (count === 0) {
			item._proportion_ = (1 / series.length) * process
			item._rose_proportion_ = (1 / series.length) * process
		} else {
			item._proportion_ = (item.data / count) * process
			if (type == 'area') {
				item._rose_proportion_ = (1 / series.length) * process
			} else {
				item._rose_proportion_ = (item.data / count) * process
			}
		}
		item._radius_ =
			minRadius +
				radiusLength * ((item.data - minData) / (maxData - minData)) ||
			radius
	}
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item._start_ = _start_
		_start_ += 2 * item._rose_proportion_ * Math.PI
	}
	return series
}

function getArcbarDataPoints(series, arcbarOption) {
	var process =
		arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
	if (process == 1) {
		process = 0.999999
	}
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		let totalAngle
		if (arcbarOption.type == 'circle') {
			totalAngle = 2
		} else {
			if (arcbarOption.direction == 'ccw') {
				if (arcbarOption.startAngle < arcbarOption.endAngle) {
					totalAngle =
						2 + arcbarOption.startAngle - arcbarOption.endAngle
				} else {
					totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
				}
			} else {
				if (arcbarOption.endAngle < arcbarOption.startAngle) {
					totalAngle =
						2 + arcbarOption.endAngle - arcbarOption.startAngle
				} else {
					totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
				}
			}
		}
		item._proportion_ =
			totalAngle * item.data * process + arcbarOption.startAngle
		if (arcbarOption.direction == 'ccw') {
			item._proportion_ =
				arcbarOption.startAngle - totalAngle * item.data * process
		}
		if (item._proportion_ >= 2) {
			item._proportion_ = item._proportion_ % 2
		}
	}
	return series
}

function getGaugeArcbarDataPoints(series, arcbarOption) {
	var process =
		arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1
	if (process == 1) {
		process = 0.999999
	}
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		let totalAngle
		if (arcbarOption.type == 'circle') {
			totalAngle = 2
		} else {
			if (arcbarOption.endAngle < arcbarOption.startAngle) {
				totalAngle = 2 + arcbarOption.endAngle - arcbarOption.startAngle
			} else {
				totalAngle = arcbarOption.startAngle - arcbarOption.endAngle
			}
		}
		item._proportion_ =
			totalAngle * item.data * process + arcbarOption.startAngle
		if (item._proportion_ >= 2) {
			item._proportion_ = item._proportion_ % 2
		}
	}
	return series
}

function getGaugeAxisPoints(categories, startAngle, endAngle) {
	let totalAngle
	if (endAngle < startAngle) {
		totalAngle = 2 + endAngle - startAngle
	} else {
		totalAngle = startAngle - endAngle
	}
	let tempStartAngle = startAngle
	for (let i = 0; i < categories.length; i++) {
		categories[i].value =
			categories[i].value === null ? 0 : categories[i].value
		categories[i]._startAngle_ = tempStartAngle
		categories[i]._endAngle_ = totalAngle * categories[i].value + startAngle
		if (categories[i]._endAngle_ >= 2) {
			categories[i]._endAngle_ = categories[i]._endAngle_ % 2
		}
		tempStartAngle = categories[i]._endAngle_
	}
	return categories
}

function getGaugeDataPoints(series, categories, gaugeOption) {
	let process =
		arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		item.data = item.data === null ? 0 : item.data
		if (gaugeOption.pointer.color == 'auto') {
			for (let i = 0; i < categories.length; i++) {
				if (item.data <= categories[i].value) {
					item.color = categories[i].color
					break
				}
			}
		} else {
			item.color = gaugeOption.pointer.color
		}
		let totalAngle
		if (gaugeOption.endAngle < gaugeOption.startAngle) {
			totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
		} else {
			totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
		}
		item._endAngle_ = totalAngle * item.data + gaugeOption.startAngle
		item._oldAngle_ = gaugeOption.oldAngle
		if (gaugeOption.oldAngle < gaugeOption.endAngle) {
			item._oldAngle_ += 2
		}
		if (item.data >= gaugeOption.oldData) {
			item._proportion_ =
				(item._endAngle_ - item._oldAngle_) * process +
				gaugeOption.oldAngle
		} else {
			item._proportion_ =
				item._oldAngle_ - (item._oldAngle_ - item._endAngle_) * process
		}
		if (item._proportion_ >= 2) {
			item._proportion_ = item._proportion_ % 2
		}
	}
	return series
}

function getPieTextMaxLength(series, config, context, opts) {
	series = getPieDataPoints(series)
	let maxLength = 0
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		let text = item.formatter
			? item.formatter(+item._proportion_.toFixed(2))
			: util.toFixed(item._proportion_ * 100) + '%'
		maxLength = Math.max(
			maxLength,
			measureText(
				text,
				item.textSize * opts.pix || config.fontSize,
				context
			)
		)
	}
	return maxLength
}

function fixColumeData(points, eachSpacing, columnLen, index, config, opts) {
	return points.map(function (item) {
		if (item === null) {
			return null
		}
		var seriesGap = 0
		var categoryGap = 0
		if (opts.type == 'mix') {
			seriesGap = opts.extra.mix.column.seriesGap * opts.pix || 0
			categoryGap = opts.extra.mix.column.categoryGap * opts.pix || 0
		} else {
			seriesGap = opts.extra.column.seriesGap * opts.pix || 0
			categoryGap = opts.extra.column.categoryGap * opts.pix || 0
		}
		seriesGap = Math.min(seriesGap, eachSpacing / columnLen)
		categoryGap = Math.min(categoryGap, eachSpacing / columnLen)
		item.width = Math.ceil(
			(eachSpacing - 2 * categoryGap - seriesGap * (columnLen - 1)) /
				columnLen
		)
		if (
			opts.extra.mix &&
			opts.extra.mix.column.width &&
			+opts.extra.mix.column.width > 0
		) {
			item.width = Math.min(
				item.width,
				+opts.extra.mix.column.width * opts.pix
			)
		}
		if (
			opts.extra.column &&
			opts.extra.column.width &&
			+opts.extra.column.width > 0
		) {
			item.width = Math.min(
				item.width,
				+opts.extra.column.width * opts.pix
			)
		}
		if (item.width <= 0) {
			item.width = 1
		}
		item.x += (index + 0.5 - columnLen / 2) * (item.width + seriesGap)
		return item
	})
}

function fixBarData(points, eachSpacing, columnLen, index, config, opts) {
	return points.map(function (item) {
		if (item === null) {
			return null
		}
		var seriesGap = 0
		var categoryGap = 0
		seriesGap = opts.extra.bar.seriesGap * opts.pix || 0
		categoryGap = opts.extra.bar.categoryGap * opts.pix || 0
		seriesGap = Math.min(seriesGap, eachSpacing / columnLen)
		categoryGap = Math.min(categoryGap, eachSpacing / columnLen)
		item.width = Math.ceil(
			(eachSpacing - 2 * categoryGap - seriesGap * (columnLen - 1)) /
				columnLen
		)
		if (
			opts.extra.bar &&
			opts.extra.bar.width &&
			+opts.extra.bar.width > 0
		) {
			item.width = Math.min(item.width, +opts.extra.bar.width * opts.pix)
		}
		if (item.width <= 0) {
			item.width = 1
		}
		item.y += (index + 0.5 - columnLen / 2) * (item.width + seriesGap)
		return item
	})
}

function fixColumeMeterData(
	points,
	eachSpacing,
	columnLen,
	index,
	config,
	opts,
	border
) {
	var categoryGap = opts.extra.column.categoryGap * opts.pix || 0
	return points.map(function (item) {
		if (item === null) {
			return null
		}
		item.width = eachSpacing - 2 * categoryGap
		if (
			opts.extra.column &&
			opts.extra.column.width &&
			+opts.extra.column.width > 0
		) {
			item.width = Math.min(
				item.width,
				+opts.extra.column.width * opts.pix
			)
		}
		if (index > 0) {
			item.width -= border
		}
		return item
	})
}

function fixColumeStackData(
	points,
	eachSpacing,
	columnLen,
	index,
	config,
	opts,
	series
) {
	var categoryGap = opts.extra.column.categoryGap * opts.pix || 0
	return points.map(function (item, indexn) {
		if (item === null) {
			return null
		}
		item.width = Math.ceil(eachSpacing - 2 * categoryGap)
		if (
			opts.extra.column &&
			opts.extra.column.width &&
			+opts.extra.column.width > 0
		) {
			item.width = Math.min(
				item.width,
				+opts.extra.column.width * opts.pix
			)
		}
		if (item.width <= 0) {
			item.width = 1
		}
		return item
	})
}

function fixBarStackData(
	points,
	eachSpacing,
	columnLen,
	index,
	config,
	opts,
	series
) {
	var categoryGap = opts.extra.bar.categoryGap * opts.pix || 0
	return points.map(function (item, indexn) {
		if (item === null) {
			return null
		}
		item.width = Math.ceil(eachSpacing - 2 * categoryGap)
		if (
			opts.extra.bar &&
			opts.extra.bar.width &&
			+opts.extra.bar.width > 0
		) {
			item.width = Math.min(item.width, +opts.extra.bar.width * opts.pix)
		}
		if (item.width <= 0) {
			item.width = 1
		}
		return item
	})
}

function getXAxisPoints(categories, opts, config) {
	var spacingValid = opts.width - opts.area[1] - opts.area[3]
	var dataCount = opts.enableScroll
		? Math.min(opts.xAxis.itemCount, categories.length)
		: categories.length
	if (
		(opts.type == 'line' ||
			opts.type == 'area' ||
			opts.type == 'scatter' ||
			opts.type == 'bubble' ||
			opts.type == 'bar') &&
		dataCount > 1 &&
		opts.xAxis.boundaryGap == 'justify'
	) {
		dataCount -= 1
	}
	var widthRatio = 0
	if (
		opts.type == 'mount' &&
		opts.extra &&
		opts.extra.mount &&
		opts.extra.mount.widthRatio &&
		opts.extra.mount.widthRatio > 1
	) {
		if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
		widthRatio = opts.extra.mount.widthRatio - 1
		dataCount += widthRatio
	}
	var eachSpacing = spacingValid / dataCount
	var xAxisPoints = []
	var startX = opts.area[3]
	var endX = opts.width - opts.area[1]
	categories.forEach(function (item, index) {
		xAxisPoints.push(
			startX + (widthRatio / 2) * eachSpacing + index * eachSpacing
		)
	})
	if (opts.xAxis.boundaryGap !== 'justify') {
		if (opts.enableScroll === true) {
			xAxisPoints.push(
				startX +
					widthRatio * eachSpacing +
					categories.length * eachSpacing
			)
		} else {
			xAxisPoints.push(endX)
		}
	}
	return {
		xAxisPoints: xAxisPoints,
		startX: startX,
		endX: endX,
		eachSpacing: eachSpacing,
	}
}

function getCandleDataPoints(
	data,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	config
) {
	var process =
		arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var cPoints = []
			item.forEach(function (items, indexs) {
				var point = {}
				point.x = xAxisPoints[index] + Math.round(eachSpacing / 2)
				var value = items.value || items
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				height *= process
				point.y = opts.height - Math.round(height) - opts.area[2]
				cPoints.push(point)
			})
			points.push(cPoints)
		}
	})
	return points
}

function getDataPoints(
	data,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	config
) {
	var process =
		arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
	var boundaryGap = 'center'
	if (
		opts.type == 'line' ||
		opts.type == 'area' ||
		opts.type == 'scatter' ||
		opts.type == 'bubble'
	) {
		boundaryGap = opts.xAxis.boundaryGap
	}
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	var validWidth = opts.width - opts.area[1] - opts.area[3]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.x = xAxisPoints[index]
			var value = item
			if (typeof item === 'object' && item !== null) {
				if (item.constructor.toString().indexOf('Array') > -1) {
					let xranges, xminRange, xmaxRange
					xranges = [].concat(opts.chartData.xAxisData.ranges)
					xminRange = xranges.shift()
					xmaxRange = xranges.pop()
					value = item[1]
					point.x =
						opts.area[3] +
						(validWidth * (item[0] - xminRange)) /
							(xmaxRange - xminRange)
					if (opts.type == 'bubble') {
						point.r = item[2]
						point.t = item[3]
					}
				} else {
					value = item.value
				}
			}
			if (boundaryGap == 'center') {
				point.x += eachSpacing / 2
			}
			var height =
				(validHeight * (value - minRange)) / (maxRange - minRange)
			height *= process
			point.y = opts.height - height - opts.area[2]
			points.push(point)
		}
	})
	return points
}

function getLineDataPoints(
	data,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	config,
	lineOption,
	process
) {
	var process =
		arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
	var boundaryGap = opts.xAxis.boundaryGap
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	var validWidth = opts.width - opts.area[1] - opts.area[3]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			if (lineOption.animation == 'vertical') {
				point.x = xAxisPoints[index]
				var value = item
				if (typeof item === 'object' && item !== null) {
					if (item.constructor.toString().indexOf('Array') > -1) {
						let xranges, xminRange, xmaxRange
						xranges = [].concat(opts.chartData.xAxisData.ranges)
						xminRange = xranges.shift()
						xmaxRange = xranges.pop()
						value = item[1]
						point.x =
							opts.area[3] +
							(validWidth * (item[0] - xminRange)) /
								(xmaxRange - xminRange)
					} else {
						value = item.value
					}
				}
				if (boundaryGap == 'center') {
					point.x += eachSpacing / 2
				}
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				height *= process
				point.y = opts.height - height - opts.area[2]
				points.push(point)
			} else {
				point.x = xAxisPoints[0] + eachSpacing * index * process
				var value = item
				if (boundaryGap == 'center') {
					point.x += eachSpacing / 2
				}
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				point.y = opts.height - height - opts.area[2]
				points.push(point)
			}
		}
	})
	return points
}

function getColumnDataPoints(
	data,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	config,
	zeroPoints,
	process
) {
	var process =
		arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	var validWidth = opts.width - opts.area[1] - opts.area[3]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.x = xAxisPoints[index]
			var value = item
			if (typeof item === 'object' && item !== null) {
				if (item.constructor.toString().indexOf('Array') > -1) {
					let xranges, xminRange, xmaxRange
					xranges = [].concat(opts.chartData.xAxisData.ranges)
					xminRange = xranges.shift()
					xmaxRange = xranges.pop()
					value = item[1]
					point.x =
						opts.area[3] +
						(validWidth * (item[0] - xminRange)) /
							(xmaxRange - xminRange)
				} else {
					value = item.value
				}
			}
			point.x += eachSpacing / 2
			var height =
				(validHeight * (value * process - minRange)) /
				(maxRange - minRange)
			point.y = opts.height - height - opts.area[2]
			points.push(point)
		}
	})
	return points
}

function getMountDataPoints(
	series,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	mountOption,
	zeroPoints
) {
	var process =
		arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : 1
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	var validWidth = opts.width - opts.area[1] - opts.area[3]
	var mountWidth = eachSpacing * mountOption.widthRatio
	series.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.x = xAxisPoints[index]
			point.x += eachSpacing / 2
			var value = item.data
			var height =
				(validHeight * (value * process - minRange)) /
				(maxRange - minRange)
			point.y = opts.height - height - opts.area[2]
			point.value = value
			point.width = mountWidth
			points.push(point)
		}
	})
	return points
}

function getBarDataPoints(
	data,
	minRange,
	maxRange,
	yAxisPoints,
	eachSpacing,
	opts,
	config
) {
	var process =
		arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 1
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	var validWidth = opts.width - opts.area[1] - opts.area[3]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.y = yAxisPoints[index]
			var value = item
			if (typeof item === 'object' && item !== null) {
				value = item.value
			}
			var height =
				(validWidth * (value - minRange)) / (maxRange - minRange)
			height *= process
			point.height = height
			point.value = value
			point.x = height + opts.area[3]
			points.push(point)
		}
	})
	return points
}

function getStackDataPoints(
	data,
	minRange,
	maxRange,
	xAxisPoints,
	eachSpacing,
	opts,
	config,
	seriesIndex,
	stackSeries
) {
	var process =
		arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 1
	var points = []
	var validHeight = opts.height - opts.area[0] - opts.area[2]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.x = xAxisPoints[index] + Math.round(eachSpacing / 2)

			if (seriesIndex > 0) {
				var value = 0
				for (let i = 0; i <= seriesIndex; i++) {
					value += stackSeries[i].data[index]
				}
				var value0 = value - item
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				var height0 =
					(validHeight * (value0 - minRange)) / (maxRange - minRange)
			} else {
				var value = item
				if (typeof item === 'object' && item !== null) {
					value = item.value
				}
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				var height0 = 0
			}
			var heightc = height0
			height *= process
			heightc *= process
			point.y = opts.height - Math.round(height) - opts.area[2]
			point.y0 = opts.height - Math.round(heightc) - opts.area[2]
			points.push(point)
		}
	})
	return points
}

function getBarStackDataPoints(
	data,
	minRange,
	maxRange,
	yAxisPoints,
	eachSpacing,
	opts,
	config,
	seriesIndex,
	stackSeries
) {
	var process =
		arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : 1
	var points = []
	var validHeight = opts.width - opts.area[1] - opts.area[3]
	data.forEach(function (item, index) {
		if (item === null) {
			points.push(null)
		} else {
			var point = {}
			point.color = item.color
			point.y = yAxisPoints[index]
			if (seriesIndex > 0) {
				var value = 0
				for (let i = 0; i <= seriesIndex; i++) {
					value += stackSeries[i].data[index]
				}
				var value0 = value - item
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				var height0 =
					(validHeight * (value0 - minRange)) / (maxRange - minRange)
			} else {
				var value = item
				if (typeof item === 'object' && item !== null) {
					value = item.value
				}
				var height =
					(validHeight * (value - minRange)) / (maxRange - minRange)
				var height0 = 0
			}
			var heightc = height0
			height *= process
			heightc *= process
			point.height = height - heightc
			point.x = opts.area[3] + height
			point.x0 = opts.area[3] + heightc
			points.push(point)
		}
	})
	return points
}

function getYAxisTextList(series, opts, config, stack, yData) {
	var index =
		arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : -1
	var data
	if (stack == 'stack') {
		data = dataCombineStack(series, opts.categories.length)
	} else {
		data = dataCombine(series)
	}
	var sorted = []
	// remove null from data
	data = data.filter(function (item) {
		//return item !== null;
		if (typeof item === 'object' && item !== null) {
			if (item.constructor.toString().indexOf('Array') > -1) {
				return item !== null
			} else {
				return item.value !== null
			}
		} else {
			return item !== null
		}
	})
	data.map(function (item) {
		if (typeof item === 'object') {
			if (item.constructor.toString().indexOf('Array') > -1) {
				if (opts.type == 'candle') {
					item.map(function (subitem) {
						sorted.push(subitem)
					})
				} else {
					sorted.push(item[1])
				}
			} else {
				sorted.push(item.value)
			}
		} else {
			sorted.push(item)
		}
	})
	var minData = yData.min || 0
	var maxData = yData.max || 0
	if (sorted.length > 0) {
		minData = Math.min.apply(this, sorted)
		maxData = Math.max.apply(this, sorted)
	}
	if (minData === maxData) {
		if (maxData == 0) {
			maxData = 10
		} else {
			minData = 0
		}
	}
	var dataRange = getDataRange(minData, maxData)
	var minRange =
		yData.min === undefined || yData.min === null
			? dataRange.minRange
			: yData.min
	var maxRange =
		yData.max === undefined || yData.max === null
			? dataRange.maxRange
			: yData.max
	var eachRange = (maxRange - minRange) / opts.yAxis.splitNumber
	var range = []
	for (var i = 0; i <= opts.yAxis.splitNumber; i++) {
		range.push(minRange + eachRange * i)
	}
	return range.reverse()
}

function calYAxisData(series, opts, config, context) {
	//堆叠图重算Y轴
	var columnstyle = assign(
		{},
		{
			type: '',
		},
		opts.extra.column
	)
	//如果是多Y轴，重新计算
	var YLength = opts.yAxis.data.length
	var newSeries = new Array(YLength)
	if (YLength > 0) {
		for (let i = 0; i < YLength; i++) {
			newSeries[i] = []
			for (let j = 0; j < series.length; j++) {
				if (series[j].index == i) {
					newSeries[i].push(series[j])
				}
			}
		}
		var rangesArr = new Array(YLength)
		var rangesFormatArr = new Array(YLength)
		var yAxisWidthArr = new Array(YLength)

		for (let i = 0; i < YLength; i++) {
			let yData = opts.yAxis.data[i]
			//如果总开关不显示，强制每个Y轴为不显示
			if (opts.yAxis.disabled == true) {
				yData.disabled = true
			}
			if (yData.type === 'categories') {
				if (!yData.formatter) {
					yData.formatter = (val, index, opts) => {
						return val + (yData.unit || '')
					}
				}
				yData.categories = yData.categories || opts.categories
				rangesArr[i] = yData.categories
			} else {
				if (!yData.formatter) {
					yData.formatter = (val, index, opts) => {
						return (
							util.toFixed(val, yData.tofix || 0) +
							(yData.unit || '')
						)
					}
				}
				rangesArr[i] = getYAxisTextList(
					newSeries[i],
					opts,
					config,
					columnstyle.type,
					yData,
					i
				)
			}
			let yAxisFontSizes = yData.fontSize * opts.pix || config.fontSize
			yAxisWidthArr[i] = {
				position: yData.position ? yData.position : 'left',
				width: 0,
			}
			rangesFormatArr[i] = rangesArr[i].map(function (items, index) {
				items = yData.formatter(items, index, opts)
				yAxisWidthArr[i].width = Math.max(
					yAxisWidthArr[i].width,
					measureText(items, yAxisFontSizes, context) + 5
				)
				return items
			})
			let calibration = yData.calibration ? 4 * opts.pix : 0
			yAxisWidthArr[i].width += calibration + 3 * opts.pix
			if (yData.disabled === true) {
				yAxisWidthArr[i].width = 0
			}
		}
	} else {
		var rangesArr = new Array(1)
		var rangesFormatArr = new Array(1)
		var yAxisWidthArr = new Array(1)
		if (opts.type === 'bar') {
			rangesArr[0] = opts.categories
			if (!opts.yAxis.formatter) {
				opts.yAxis.formatter = (val, index, opts) => {
					return val + (opts.yAxis.unit || '')
				}
			}
		} else {
			if (!opts.yAxis.formatter) {
				opts.yAxis.formatter = (val, index, opts) => {
					return (
						val.toFixed(opts.yAxis.tofix) + (opts.yAxis.unit || '')
					)
				}
			}
			rangesArr[0] = getYAxisTextList(
				series,
				opts,
				config,
				columnstyle.type,
				{}
			)
		}
		yAxisWidthArr[0] = {
			position: 'left',
			width: 0,
		}
		var yAxisFontSize = opts.yAxis.fontSize * opts.pix || config.fontSize
		rangesFormatArr[0] = rangesArr[0].map(function (item, index) {
			item = opts.yAxis.formatter(item, index, opts)
			yAxisWidthArr[0].width = Math.max(
				yAxisWidthArr[0].width,
				measureText(item, yAxisFontSize, context) + 5
			)
			return item
		})
		yAxisWidthArr[0].width += 3 * opts.pix
		if (opts.yAxis.disabled === true) {
			yAxisWidthArr[0] = {
				position: 'left',
				width: 0,
			}
			opts.yAxis.data[0] = {
				disabled: true,
			}
		} else {
			opts.yAxis.data[0] = {
				disabled: false,
				position: 'left',
				max: opts.yAxis.max,
				min: opts.yAxis.min,
				formatter: opts.yAxis.formatter,
			}
			if (opts.type === 'bar') {
				opts.yAxis.data[0].categories = opts.categories
				opts.yAxis.data[0].type = 'categories'
			}
		}
	}
	return {
		rangesFormat: rangesFormatArr,
		ranges: rangesArr,
		yAxisWidth: yAxisWidthArr,
	}
}

function calTooltipYAxisData(point, series, opts, config, eachSpacing) {
	let ranges = [].concat(opts.chartData.yAxisData.ranges)
	let spacingValid = opts.height - opts.area[0] - opts.area[2]
	let minAxis = opts.area[0]
	let items = []
	for (let i = 0; i < ranges.length; i++) {
		let maxVal = Math.max.apply(this, ranges[i])
		let minVal = Math.min.apply(this, ranges[i])
		let item =
			maxVal - ((maxVal - minVal) * (point - minAxis)) / spacingValid
		item =
			opts.yAxis.data && opts.yAxis.data[i].formatter
				? opts.yAxis.data[i].formatter(item, i, opts)
				: item.toFixed(0)
		items.push(String(item))
	}
	return items
}

function calMarkLineData(points, opts) {
	let minRange, maxRange
	let spacingValid = opts.height - opts.area[0] - opts.area[2]
	for (let i = 0; i < points.length; i++) {
		points[i].yAxisIndex = points[i].yAxisIndex ? points[i].yAxisIndex : 0
		let range = [].concat(
			opts.chartData.yAxisData.ranges[points[i].yAxisIndex]
		)
		minRange = range.pop()
		maxRange = range.shift()
		let height =
			(spacingValid * (points[i].value - minRange)) /
			(maxRange - minRange)
		points[i].y = opts.height - Math.round(height) - opts.area[2]
	}
	return points
}

function contextRotate(context, opts) {
	if (opts.rotateLock !== true) {
		context.translate(opts.height, 0)
		context.rotate((90 * Math.PI) / 180)
	} else if (opts._rotate_ !== true) {
		context.translate(opts.height, 0)
		context.rotate((90 * Math.PI) / 180)
		opts._rotate_ = true
	}
}

function drawPointShape(points, color, shape, context, opts) {
	context.beginPath()
	if (opts.dataPointShapeType == 'hollow') {
		context.setStrokeStyle(color)
		context.setFillStyle(opts.background)
		context.setLineWidth(2 * opts.pix)
	} else {
		context.setStrokeStyle('#ffffff')
		context.setFillStyle(color)
		context.setLineWidth(1 * opts.pix)
	}
	if (shape === 'diamond') {
		points.forEach(function (item, index) {
			if (item !== null) {
				context.moveTo(item.x, item.y - 4.5)
				context.lineTo(item.x - 4.5, item.y)
				context.lineTo(item.x, item.y + 4.5)
				context.lineTo(item.x + 4.5, item.y)
				context.lineTo(item.x, item.y - 4.5)
			}
		})
	} else if (shape === 'circle') {
		points.forEach(function (item, index) {
			if (item !== null) {
				context.moveTo(item.x + 2.5 * opts.pix, item.y)
				context.arc(item.x, item.y, 3 * opts.pix, 0, 2 * Math.PI, false)
			}
		})
	} else if (shape === 'square') {
		points.forEach(function (item, index) {
			if (item !== null) {
				context.moveTo(item.x - 3.5, item.y - 3.5)
				context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
			}
		})
	} else if (shape === 'triangle') {
		points.forEach(function (item, index) {
			if (item !== null) {
				context.moveTo(item.x, item.y - 4.5)
				context.lineTo(item.x - 4.5, item.y + 4.5)
				context.lineTo(item.x + 4.5, item.y + 4.5)
				context.lineTo(item.x, item.y - 4.5)
			}
		})
	} else if (shape === 'none') {
		return
	}
	context.closePath()
	context.fill()
	context.stroke()
}

function drawActivePoint(
	points,
	color,
	shape,
	context,
	opts,
	option,
	seriesIndex
) {
	if (!opts.tooltip) {
		return
	}
	if (
		opts.tooltip.group.length > 0 &&
		opts.tooltip.group.includes(seriesIndex) == false
	) {
		return
	}
	var pointIndex =
		typeof opts.tooltip.index === 'number'
			? opts.tooltip.index
			: opts.tooltip.index[opts.tooltip.group.indexOf(seriesIndex)]
	context.beginPath()
	if (option.activeType == 'hollow') {
		context.setStrokeStyle(color)
		context.setFillStyle(opts.background)
		context.setLineWidth(2 * opts.pix)
	} else {
		context.setStrokeStyle('#ffffff')
		context.setFillStyle(color)
		context.setLineWidth(1 * opts.pix)
	}
	if (shape === 'diamond') {
		points.forEach(function (item, index) {
			if (item !== null && pointIndex == index) {
				context.moveTo(item.x, item.y - 4.5)
				context.lineTo(item.x - 4.5, item.y)
				context.lineTo(item.x, item.y + 4.5)
				context.lineTo(item.x + 4.5, item.y)
				context.lineTo(item.x, item.y - 4.5)
			}
		})
	} else if (shape === 'circle') {
		points.forEach(function (item, index) {
			if (item !== null && pointIndex == index) {
				context.moveTo(item.x + 2.5 * opts.pix, item.y)
				context.arc(item.x, item.y, 3 * opts.pix, 0, 2 * Math.PI, false)
			}
		})
	} else if (shape === 'square') {
		points.forEach(function (item, index) {
			if (item !== null && pointIndex == index) {
				context.moveTo(item.x - 3.5, item.y - 3.5)
				context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
			}
		})
	} else if (shape === 'triangle') {
		points.forEach(function (item, index) {
			if (item !== null && pointIndex == index) {
				context.moveTo(item.x, item.y - 4.5)
				context.lineTo(item.x - 4.5, item.y + 4.5)
				context.lineTo(item.x + 4.5, item.y + 4.5)
				context.lineTo(item.x, item.y - 4.5)
			}
		})
	} else if (shape === 'none') {
		return
	}
	context.closePath()
	context.fill()
	context.stroke()
}

function drawRingTitle(opts, config, context, center) {
	var titlefontSize = opts.title.fontSize || config.titleFontSize
	var subtitlefontSize = opts.subtitle.fontSize || config.subtitleFontSize
	var title = opts.title.name || ''
	var subtitle = opts.subtitle.name || ''
	var titleFontColor = opts.title.color || opts.fontColor
	var subtitleFontColor = opts.subtitle.color || opts.fontColor
	var titleHeight = title ? titlefontSize : 0
	var subtitleHeight = subtitle ? subtitlefontSize : 0
	var margin = 5
	if (subtitle) {
		var textWidth = measureText(
			subtitle,
			subtitlefontSize * opts.pix,
			context
		)
		var startX =
			center.x - textWidth / 2 + (opts.subtitle.offsetX || 0) * opts.pix
		var startY =
			center.y +
			(subtitlefontSize * opts.pix) / 2 +
			(opts.subtitle.offsetY || 0) * opts.pix
		if (title) {
			startY += (titleHeight * opts.pix + margin) / 2
		}
		context.beginPath()
		context.setFontSize(subtitlefontSize * opts.pix)
		context.setFillStyle(subtitleFontColor)
		context.fillText(subtitle, startX, startY)
		context.closePath()
		context.stroke()
	}
	if (title) {
		var _textWidth = measureText(title, titlefontSize * opts.pix, context)
		var _startX = center.x - _textWidth / 2 + (opts.title.offsetX || 0)
		var _startY =
			center.y +
			(titlefontSize * opts.pix) / 2 +
			(opts.title.offsetY || 0) * opts.pix
		if (subtitle) {
			_startY -= (subtitleHeight * opts.pix + margin) / 2
		}
		context.beginPath()
		context.setFontSize(titlefontSize * opts.pix)
		context.setFillStyle(titleFontColor)
		context.fillText(title, _startX, _startY)
		context.closePath()
		context.stroke()
	}
}

function drawPointText(points, series, config, context, opts) {
	// 绘制数据文案
	var data = series.data
	var textOffset = series.textOffset ? series.textOffset : 0
	points.forEach(function (item, index) {
		if (item !== null) {
			context.beginPath()
			var fontSize = series.textSize
				? series.textSize * opts.pix
				: config.fontSize
			context.setFontSize(fontSize)
			context.setFillStyle(series.textColor || opts.fontColor)
			var value = data[index]
			if (typeof data[index] === 'object' && data[index] !== null) {
				if (data[index].constructor.toString().indexOf('Array') > -1) {
					value = data[index][1]
				} else {
					value = data[index].value
				}
			}
			var formatVal = series.formatter
				? series.formatter(value, index, series, opts)
				: value
			context.setTextAlign('center')
			context.fillText(
				String(formatVal),
				item.x,
				item.y - 4 + textOffset * opts.pix
			)
			context.closePath()
			context.stroke()
			context.setTextAlign('left')
		}
	})
}

function drawColumePointText(points, series, config, context, opts) {
	// 绘制数据文案
	var data = series.data
	var textOffset = series.textOffset ? series.textOffset : 0
	var Position = opts.extra.column.labelPosition
	points.forEach(function (item, index) {
		if (item !== null) {
			context.beginPath()
			var fontSize = series.textSize
				? series.textSize * opts.pix
				: config.fontSize
			context.setFontSize(fontSize)
			context.setFillStyle(series.textColor || opts.fontColor)
			var value = data[index]
			if (typeof data[index] === 'object' && data[index] !== null) {
				if (data[index].constructor.toString().indexOf('Array') > -1) {
					value = data[index][1]
				} else {
					value = data[index].value
				}
			}
			var formatVal = series.formatter
				? series.formatter(value, index, series, opts)
				: value
			context.setTextAlign('center')
			var startY = item.y - 4 * opts.pix + textOffset * opts.pix
			if (item.y > series.zeroPoints) {
				startY = item.y + textOffset * opts.pix + fontSize
			}
			if (Position == 'insideTop') {
				startY = item.y + fontSize + textOffset * opts.pix
				if (item.y > series.zeroPoints) {
					startY = item.y - textOffset * opts.pix - 4 * opts.pix
				}
			}
			if (Position == 'center') {
				startY =
					item.y +
					textOffset * opts.pix +
					(opts.height - opts.area[2] - item.y + fontSize) / 2
				if (series.zeroPoints < opts.height - opts.area[2]) {
					startY =
						item.y +
						textOffset * opts.pix +
						(series.zeroPoints - item.y + fontSize) / 2
				}
				if (item.y > series.zeroPoints) {
					startY =
						item.y -
						textOffset * opts.pix -
						(item.y - series.zeroPoints - fontSize) / 2
				}
				if (opts.extra.column.type == 'stack') {
					startY =
						item.y +
						textOffset * opts.pix +
						(item.y0 - item.y + fontSize) / 2
				}
			}
			if (Position == 'bottom') {
				startY =
					opts.height -
					opts.area[2] +
					textOffset * opts.pix -
					4 * opts.pix
				if (series.zeroPoints < opts.height - opts.area[2]) {
					startY =
						series.zeroPoints + textOffset * opts.pix - 4 * opts.pix
				}
				if (item.y > series.zeroPoints) {
					startY =
						series.zeroPoints -
						textOffset * opts.pix +
						fontSize +
						2 * opts.pix
				}
				if (opts.extra.column.type == 'stack') {
					startY = item.y0 + textOffset * opts.pix - 4 * opts.pix
				}
			}
			context.fillText(String(formatVal), item.x, startY)
			context.closePath()
			context.stroke()
			context.setTextAlign('left')
		}
	})
}

function drawMountPointText(points, series, config, context, opts, zeroPoints) {
	// 绘制数据文案
	var data = series.data
	var textOffset = series.textOffset ? series.textOffset : 0
	var Position = opts.extra.mount.labelPosition
	points.forEach(function (item, index) {
		if (item !== null) {
			context.beginPath()
			var fontSize = series[index].textSize
				? series[index].textSize * opts.pix
				: config.fontSize
			context.setFontSize(fontSize)
			context.setFillStyle(series[index].textColor || opts.fontColor)
			var value = item.value
			var formatVal = series[index].formatter
				? series[index].formatter(value, index, series, opts)
				: value
			context.setTextAlign('center')
			var startY = item.y - 4 * opts.pix + textOffset * opts.pix
			if (item.y > zeroPoints) {
				startY = item.y + textOffset * opts.pix + fontSize
			}
			context.fillText(String(formatVal), item.x, startY)
			context.closePath()
			context.stroke()
			context.setTextAlign('left')
		}
	})
}

function drawBarPointText(points, series, config, context, opts) {
	// 绘制数据文案
	var data = series.data
	var textOffset = series.textOffset ? series.textOffset : 0
	points.forEach(function (item, index) {
		if (item !== null) {
			context.beginPath()
			var fontSize = series.textSize
				? series.textSize * opts.pix
				: config.fontSize
			context.setFontSize(fontSize)
			context.setFillStyle(series.textColor || opts.fontColor)
			var value = data[index]
			if (typeof data[index] === 'object' && data[index] !== null) {
				value = data[index].value
			}
			var formatVal = series.formatter
				? series.formatter(value, index, series, opts)
				: value
			context.setTextAlign('left')
			context.fillText(
				String(formatVal),
				item.x + 4 * opts.pix,
				item.y + fontSize / 2 - 3
			)
			context.closePath()
			context.stroke()
		}
	})
}

function drawGaugeLabel(
	gaugeOption,
	radius,
	centerPosition,
	opts,
	config,
	context
) {
	radius -= gaugeOption.width / 2 + gaugeOption.labelOffset * opts.pix
	radius = radius < 10 ? 10 : radius
	let totalAngle
	if (gaugeOption.endAngle < gaugeOption.startAngle) {
		totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
	} else {
		totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
	}
	let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
	let totalNumber = gaugeOption.endNumber - gaugeOption.startNumber
	let splitNumber = totalNumber / gaugeOption.splitLine.splitNumber
	let nowAngle = gaugeOption.startAngle
	let nowNumber = gaugeOption.startNumber
	for (let i = 0; i < gaugeOption.splitLine.splitNumber + 1; i++) {
		var pos = {
			x: radius * Math.cos(nowAngle * Math.PI),
			y: radius * Math.sin(nowAngle * Math.PI),
		}
		var labelText = gaugeOption.formatter
			? gaugeOption.formatter(nowNumber, i, opts)
			: nowNumber
		pos.x +=
			centerPosition.x -
			measureText(labelText, config.fontSize, context) / 2
		pos.y += centerPosition.y
		var startX = pos.x
		var startY = pos.y
		context.beginPath()
		context.setFontSize(config.fontSize)
		context.setFillStyle(gaugeOption.labelColor || opts.fontColor)
		context.fillText(labelText, startX, startY + config.fontSize / 2)
		context.closePath()
		context.stroke()
		nowAngle += splitAngle
		if (nowAngle >= 2) {
			nowAngle = nowAngle % 2
		}
		nowNumber += splitNumber
	}
}

function drawRadarLabel(
	angleList,
	radius,
	centerPosition,
	opts,
	config,
	context
) {
	var radarOption = opts.extra.radar || {}
	angleList.forEach(function (angle, index) {
		if (
			radarOption.labelPointShow === true &&
			opts.categories[index] !== ''
		) {
			var posPoint = {
				x: radius * Math.cos(angle),
				y: radius * Math.sin(angle),
			}
			var posPointAxis = convertCoordinateOrigin(
				posPoint.x,
				posPoint.y,
				centerPosition
			)
			context.setFillStyle(radarOption.labelPointColor)
			context.beginPath()
			context.arc(
				posPointAxis.x,
				posPointAxis.y,
				radarOption.labelPointRadius * opts.pix,
				0,
				2 * Math.PI,
				false
			)
			context.closePath()
			context.fill()
		}
		if (radarOption.labelShow === true) {
			var pos = {
				x:
					(radius + config.radarLabelTextMargin * opts.pix) *
					Math.cos(angle),
				y:
					(radius + config.radarLabelTextMargin * opts.pix) *
					Math.sin(angle),
			}
			var posRelativeCanvas = convertCoordinateOrigin(
				pos.x,
				pos.y,
				centerPosition
			)
			var startX = posRelativeCanvas.x
			var startY = posRelativeCanvas.y
			if (util.approximatelyEqual(pos.x, 0)) {
				startX -=
					measureText(
						opts.categories[index] || '',
						config.fontSize,
						context
					) / 2
			} else if (pos.x < 0) {
				startX -= measureText(
					opts.categories[index] || '',
					config.fontSize,
					context
				)
			}
			context.beginPath()
			context.setFontSize(config.fontSize)
			context.setFillStyle(radarOption.labelColor || opts.fontColor)
			context.fillText(
				opts.categories[index] || '',
				startX,
				startY + config.fontSize / 2
			)
			context.closePath()
			context.stroke()
		}
	})
}

function drawPieText(series, opts, config, context, radius, center) {
	var lineRadius = config.pieChartLinePadding
	var textObjectCollection = []
	var lastTextObject = null
	var seriesConvert = series.map(function (item, index) {
		var text = item.formatter
			? item.formatter(item, index, series, opts)
			: util.toFixed(item._proportion_.toFixed(4) * 100) + '%'
		text = item.labelText ? item.labelText : text
		var arc =
			2 * Math.PI - (item._start_ + (2 * Math.PI * item._proportion_) / 2)
		if (item._rose_proportion_) {
			arc =
				2 * Math.PI -
				(item._start_ + (2 * Math.PI * item._rose_proportion_) / 2)
		}
		var color = item.color
		var radius = item._radius_
		return {
			arc: arc,
			text: text,
			color: color,
			radius: radius,
			textColor: item.textColor,
			textSize: item.textSize,
			labelShow: item.labelShow,
		}
	})
	for (let i = 0; i < seriesConvert.length; i++) {
		let item = seriesConvert[i]
		// line end
		let orginX1 = Math.cos(item.arc) * (item.radius + lineRadius)
		let orginY1 = Math.sin(item.arc) * (item.radius + lineRadius)
		// line start
		let orginX2 = Math.cos(item.arc) * item.radius
		let orginY2 = Math.sin(item.arc) * item.radius
		// text start
		let orginX3 =
			orginX1 >= 0
				? orginX1 + config.pieChartTextPadding
				: orginX1 - config.pieChartTextPadding
		let orginY3 = orginY1
		let textWidth = measureText(
			item.text,
			item.textSize * opts.pix || config.fontSize,
			context
		)
		let startY = orginY3
		if (
			lastTextObject &&
			util.isSameXCoordinateArea(lastTextObject.start, {
				x: orginX3,
			})
		) {
			if (orginX3 > 0) {
				startY = Math.min(orginY3, lastTextObject.start.y)
			} else if (orginX1 < 0) {
				startY = Math.max(orginY3, lastTextObject.start.y)
			} else {
				if (orginY3 > 0) {
					startY = Math.max(orginY3, lastTextObject.start.y)
				} else {
					startY = Math.min(orginY3, lastTextObject.start.y)
				}
			}
		}
		if (orginX3 < 0) {
			orginX3 -= textWidth
		}
		let textObject = {
			lineStart: {
				x: orginX2,
				y: orginY2,
			},
			lineEnd: {
				x: orginX1,
				y: orginY1,
			},
			start: {
				x: orginX3,
				y: startY,
			},
			width: textWidth,
			height: config.fontSize,
			text: item.text,
			color: item.color,
			textColor: item.textColor,
			textSize: item.textSize,
		}
		lastTextObject = avoidCollision(textObject, lastTextObject)
		textObjectCollection.push(lastTextObject)
	}
	for (let i = 0; i < textObjectCollection.length; i++) {
		if (seriesConvert[i].labelShow === false) {
			continue
		}
		let item = textObjectCollection[i]
		let lineStartPoistion = convertCoordinateOrigin(
			item.lineStart.x,
			item.lineStart.y,
			center
		)
		let lineEndPoistion = convertCoordinateOrigin(
			item.lineEnd.x,
			item.lineEnd.y,
			center
		)
		let textPosition = convertCoordinateOrigin(
			item.start.x,
			item.start.y,
			center
		)
		context.setLineWidth(1 * opts.pix)
		context.setFontSize(item.textSize * opts.pix || config.fontSize)
		context.beginPath()
		context.setStrokeStyle(item.color)
		context.setFillStyle(item.color)
		context.moveTo(lineStartPoistion.x, lineStartPoistion.y)
		let curveStartX =
			item.start.x < 0 ? textPosition.x + item.width : textPosition.x
		let textStartX =
			item.start.x < 0 ? textPosition.x - 5 : textPosition.x + 5
		context.quadraticCurveTo(
			lineEndPoistion.x,
			lineEndPoistion.y,
			curveStartX,
			textPosition.y
		)
		context.moveTo(lineStartPoistion.x, lineStartPoistion.y)
		context.stroke()
		context.closePath()
		context.beginPath()
		context.moveTo(textPosition.x + item.width, textPosition.y)
		context.arc(curveStartX, textPosition.y, 2 * opts.pix, 0, 2 * Math.PI)
		context.closePath()
		context.fill()
		context.beginPath()
		context.setFontSize(item.textSize * opts.pix || config.fontSize)
		context.setFillStyle(item.textColor || opts.fontColor)
		context.fillText(item.text, textStartX, textPosition.y + 3)
		context.closePath()
		context.stroke()
		context.closePath()
	}
}

function drawToolTipSplitLine(offsetX, opts, config, context) {
	var toolTipOption = opts.extra.tooltip || {}
	toolTipOption.gridType =
		toolTipOption.gridType == undefined ? 'solid' : toolTipOption.gridType
	toolTipOption.dashLength =
		toolTipOption.dashLength == undefined ? 4 : toolTipOption.dashLength
	var startY = opts.area[0]
	var endY = opts.height - opts.area[2]
	if (toolTipOption.gridType == 'dash') {
		context.setLineDash([
			toolTipOption.dashLength,
			toolTipOption.dashLength,
		])
	}
	context.setStrokeStyle(toolTipOption.gridColor || '#cccccc')
	context.setLineWidth(1 * opts.pix)
	context.beginPath()
	context.moveTo(offsetX, startY)
	context.lineTo(offsetX, endY)
	context.stroke()
	context.setLineDash([])
	if (toolTipOption.xAxisLabel) {
		let labelText = opts.categories[opts.tooltip.index]
		context.setFontSize(config.fontSize)
		let textWidth = measureText(labelText, config.fontSize, context)
		let textX = offsetX - 0.5 * textWidth
		let textY = endY + 2 * opts.pix
		context.beginPath()
		context.setFillStyle(
			hexToRgb(
				toolTipOption.labelBgColor || config.toolTipBackground,
				toolTipOption.labelBgOpacity || config.toolTipOpacity
			)
		)
		context.setStrokeStyle(
			toolTipOption.labelBgColor || config.toolTipBackground
		)
		context.setLineWidth(1 * opts.pix)
		context.rect(
			textX - toolTipOption.boxPadding * opts.pix,
			textY,
			textWidth + 2 * toolTipOption.boxPadding * opts.pix,
			config.fontSize + 2 * toolTipOption.boxPadding * opts.pix
		)
		context.closePath()
		context.stroke()
		context.fill()
		context.beginPath()
		context.setFontSize(config.fontSize)
		context.setFillStyle(toolTipOption.labelFontColor || opts.fontColor)
		context.fillText(
			String(labelText),
			textX,
			textY + toolTipOption.boxPadding * opts.pix + config.fontSize
		)
		context.closePath()
		context.stroke()
	}
}

function drawMarkLine(opts, config, context) {
	let markLineOption = assign(
		{},
		{
			type: 'solid',
			dashLength: 4,
			data: [],
		},
		opts.extra.markLine
	)
	let startX = opts.area[3]
	let endX = opts.width - opts.area[1]
	let points = calMarkLineData(markLineOption.data, opts)
	for (let i = 0; i < points.length; i++) {
		let item = assign(
			{},
			{
				lineColor: '#DE4A42',
				showLabel: false,
				labelFontSize: 13,
				labelPadding: 6,
				labelFontColor: '#666666',
				labelBgColor: '#DFE8FF',
				labelBgOpacity: 0.8,
				labelAlign: 'left',
				labelOffsetX: 0,
				labelOffsetY: 0,
			},
			points[i]
		)
		if (markLineOption.type == 'dash') {
			context.setLineDash([
				markLineOption.dashLength,
				markLineOption.dashLength,
			])
		}
		context.setStrokeStyle(item.lineColor)
		context.setLineWidth(1 * opts.pix)
		context.beginPath()
		context.moveTo(startX, item.y)
		context.lineTo(endX, item.y)
		context.stroke()
		context.setLineDash([])
		if (item.showLabel) {
			let fontSize = item.labelFontSize * opts.pix
			let labelText = item.labelText ? item.labelText : item.value
			context.setFontSize(fontSize)
			let textWidth = measureText(labelText, fontSize, context)
			let bgWidth = textWidth + item.labelPadding * opts.pix * 2
			let bgStartX =
				item.labelAlign == 'left'
					? opts.area[3] - bgWidth
					: opts.width - opts.area[1]
			bgStartX += item.labelOffsetX
			let bgStartY =
				item.y - 0.5 * fontSize - item.labelPadding * opts.pix
			bgStartY += item.labelOffsetY
			let textX = bgStartX + item.labelPadding * opts.pix
			let textY = item.y
			context.setFillStyle(
				hexToRgb(item.labelBgColor, item.labelBgOpacity)
			)
			context.setStrokeStyle(item.labelBgColor)
			context.setLineWidth(1 * opts.pix)
			context.beginPath()
			context.rect(
				bgStartX,
				bgStartY,
				bgWidth,
				fontSize + 2 * item.labelPadding * opts.pix
			)
			context.closePath()
			context.stroke()
			context.fill()
			context.setFontSize(fontSize)
			context.setTextAlign('left')
			context.setFillStyle(item.labelFontColor)
			context.fillText(
				String(labelText),
				textX,
				bgStartY + fontSize + (item.labelPadding * opts.pix) / 2
			)
			context.stroke()
			context.setTextAlign('left')
		}
	}
}

function drawToolTipHorizentalLine(
	opts,
	config,
	context,
	eachSpacing,
	xAxisPoints
) {
	var toolTipOption = assign(
		{},
		{
			gridType: 'solid',
			dashLength: 4,
		},
		opts.extra.tooltip
	)
	var startX = opts.area[3]
	var endX = opts.width - opts.area[1]
	if (toolTipOption.gridType == 'dash') {
		context.setLineDash([
			toolTipOption.dashLength,
			toolTipOption.dashLength,
		])
	}
	context.setStrokeStyle(toolTipOption.gridColor || '#cccccc')
	context.setLineWidth(1 * opts.pix)
	context.beginPath()
	context.moveTo(startX, opts.tooltip.offset.y)
	context.lineTo(endX, opts.tooltip.offset.y)
	context.stroke()
	context.setLineDash([])
	if (toolTipOption.yAxisLabel) {
		let boxPadding = toolTipOption.boxPadding * opts.pix
		let labelText = calTooltipYAxisData(
			opts.tooltip.offset.y,
			opts.series,
			opts,
			config,
			eachSpacing
		)
		let widthArr = opts.chartData.yAxisData.yAxisWidth
		let tStartLeft = opts.area[3]
		let tStartRight = opts.width - opts.area[1]
		for (let i = 0; i < labelText.length; i++) {
			context.setFontSize(toolTipOption.fontSize * opts.pix)
			let textWidth = measureText(
				labelText[i],
				toolTipOption.fontSize * opts.pix,
				context
			)
			let bgStartX, bgEndX, bgWidth
			if (widthArr[i].position == 'left') {
				bgStartX =
					tStartLeft - (textWidth + boxPadding * 2) - 2 * opts.pix
				bgEndX = Math.max(
					bgStartX,
					bgStartX + textWidth + boxPadding * 2
				)
			} else {
				bgStartX = tStartRight + 2 * opts.pix
				bgEndX = Math.max(
					bgStartX + widthArr[i].width,
					bgStartX + textWidth + boxPadding * 2
				)
			}
			bgWidth = bgEndX - bgStartX
			let textX = bgStartX + (bgWidth - textWidth) / 2
			let textY = opts.tooltip.offset.y
			context.beginPath()
			context.setFillStyle(
				hexToRgb(
					toolTipOption.labelBgColor || config.toolTipBackground,
					toolTipOption.labelBgOpacity || config.toolTipOpacity
				)
			)
			context.setStrokeStyle(
				toolTipOption.labelBgColor || config.toolTipBackground
			)
			context.setLineWidth(1 * opts.pix)
			context.rect(
				bgStartX,
				textY - 0.5 * config.fontSize - boxPadding,
				bgWidth,
				config.fontSize + 2 * boxPadding
			)
			context.closePath()
			context.stroke()
			context.fill()
			context.beginPath()
			context.setFontSize(config.fontSize)
			context.setFillStyle(toolTipOption.labelFontColor || opts.fontColor)
			context.fillText(labelText[i], textX, textY + 0.5 * config.fontSize)
			context.closePath()
			context.stroke()
			if (widthArr[i].position == 'left') {
				tStartLeft -= widthArr[i].width + opts.yAxis.padding * opts.pix
			} else {
				tStartRight += widthArr[i].width + opts.yAxis.padding * opts.pix
			}
		}
	}
}

function drawToolTipSplitArea(offsetX, opts, config, context, eachSpacing) {
	var toolTipOption = assign(
		{},
		{
			activeBgColor: '#000000',
			activeBgOpacity: 0.08,
			activeWidth: eachSpacing,
		},
		opts.extra.column
	)
	toolTipOption.activeWidth =
		toolTipOption.activeWidth > eachSpacing
			? eachSpacing
			: toolTipOption.activeWidth
	var startY = opts.area[0]
	var endY = opts.height - opts.area[2]
	context.beginPath()
	context.setFillStyle(
		hexToRgb(toolTipOption.activeBgColor, toolTipOption.activeBgOpacity)
	)
	context.rect(
		offsetX - toolTipOption.activeWidth / 2,
		startY,
		toolTipOption.activeWidth,
		endY - startY
	)
	context.closePath()
	context.fill()
	context.setFillStyle('#FFFFFF')
}

function drawBarToolTipSplitArea(offsetX, opts, config, context, eachSpacing) {
	var toolTipOption = assign(
		{},
		{
			activeBgColor: '#000000',
			activeBgOpacity: 0.08,
		},
		opts.extra.bar
	)
	var startX = opts.area[3]
	var endX = opts.width - opts.area[1]
	context.beginPath()
	context.setFillStyle(
		hexToRgb(toolTipOption.activeBgColor, toolTipOption.activeBgOpacity)
	)
	context.rect(startX, offsetX - eachSpacing / 2, endX - startX, eachSpacing)
	context.closePath()
	context.fill()
	context.setFillStyle('#FFFFFF')
}

function drawToolTip(
	textList,
	offset,
	opts,
	config,
	context,
	eachSpacing,
	xAxisPoints
) {
	var toolTipOption = assign(
		{},
		{
			showBox: true,
			showArrow: true,
			showCategory: false,
			bgColor: '#000000',
			bgOpacity: 0.7,
			borderColor: '#000000',
			borderWidth: 0,
			borderRadius: 0,
			borderOpacity: 0.7,
			boxPadding: 3,
			fontColor: '#FFFFFF',
			fontSize: 13,
			lineHeight: 20,
			legendShow: true,
			legendShape: 'auto',
			splitLine: true,
		},
		opts.extra.tooltip
	)
	if (toolTipOption.showCategory == true && opts.categories) {
		textList.unshift({
			text: opts.categories[opts.tooltip.index],
			color: null,
		})
	}
	var fontSize = toolTipOption.fontSize * opts.pix
	var lineHeight = toolTipOption.lineHeight * opts.pix
	var boxPadding = toolTipOption.boxPadding * opts.pix
	var legendWidth = fontSize
	var legendMarginRight = 5 * opts.pix
	if (toolTipOption.legendShow == false) {
		legendWidth = 0
		legendMarginRight = 0
	}
	var arrowWidth = toolTipOption.showArrow ? 8 * opts.pix : 0
	var isOverRightBorder = false
	if (
		opts.type == 'line' ||
		opts.type == 'mount' ||
		opts.type == 'area' ||
		opts.type == 'candle' ||
		opts.type == 'mix'
	) {
		if (toolTipOption.splitLine == true) {
			drawToolTipSplitLine(opts.tooltip.offset.x, opts, config, context)
		}
	}
	offset = assign(
		{
			x: 0,
			y: 0,
		},
		offset
	)
	offset.y -= 8 * opts.pix
	var textWidth = textList.map(function (item) {
		return measureText(item.text, fontSize, context)
	})
	var toolTipWidth =
		legendWidth +
		legendMarginRight +
		4 * boxPadding +
		Math.max.apply(null, textWidth)
	var toolTipHeight = 2 * boxPadding + textList.length * lineHeight
	if (toolTipOption.showBox == false) {
		return
	}
	// if beyond the right border
	if (
		offset.x -
			Math.abs(opts._scrollDistance_ || 0) +
			arrowWidth +
			toolTipWidth >
		opts.width
	) {
		isOverRightBorder = true
	}
	if (toolTipHeight + offset.y > opts.height) {
		offset.y = opts.height - toolTipHeight
	}
	// draw background rect
	context.beginPath()
	context.setFillStyle(
		hexToRgb(toolTipOption.bgColor, toolTipOption.bgOpacity)
	)
	context.setLineWidth(toolTipOption.borderWidth * opts.pix)
	context.setStrokeStyle(
		hexToRgb(toolTipOption.borderColor, toolTipOption.borderOpacity)
	)
	var radius = toolTipOption.borderRadius
	if (isOverRightBorder) {
		// 增加左侧仍然超出的判断
		if (toolTipWidth + arrowWidth > opts.width) {
			offset.x =
				opts.width +
				Math.abs(opts._scrollDistance_ || 0) +
				arrowWidth +
				(toolTipWidth - opts.width)
		}
		if (toolTipWidth > offset.x) {
			offset.x =
				opts.width +
				Math.abs(opts._scrollDistance_ || 0) +
				arrowWidth +
				(toolTipWidth - opts.width)
		}
		if (toolTipOption.showArrow) {
			context.moveTo(offset.x, offset.y + 10 * opts.pix)
			context.lineTo(
				offset.x - arrowWidth,
				offset.y + 10 * opts.pix + 5 * opts.pix
			)
		}
		context.arc(
			offset.x - arrowWidth - radius,
			offset.y + toolTipHeight - radius,
			radius,
			0,
			Math.PI / 2,
			false
		)
		context.arc(
			offset.x - arrowWidth - Math.round(toolTipWidth) + radius,
			offset.y + toolTipHeight - radius,
			radius,
			Math.PI / 2,
			Math.PI,
			false
		)
		context.arc(
			offset.x - arrowWidth - Math.round(toolTipWidth) + radius,
			offset.y + radius,
			radius,
			-Math.PI,
			-Math.PI / 2,
			false
		)
		context.arc(
			offset.x - arrowWidth - radius,
			offset.y + radius,
			radius,
			-Math.PI / 2,
			0,
			false
		)
		if (toolTipOption.showArrow) {
			context.lineTo(
				offset.x - arrowWidth,
				offset.y + 10 * opts.pix - 5 * opts.pix
			)
			context.lineTo(offset.x, offset.y + 10 * opts.pix)
		}
	} else {
		if (toolTipOption.showArrow) {
			context.moveTo(offset.x, offset.y + 10 * opts.pix)
			context.lineTo(
				offset.x + arrowWidth,
				offset.y + 10 * opts.pix - 5 * opts.pix
			)
		}
		context.arc(
			offset.x + arrowWidth + radius,
			offset.y + radius,
			radius,
			-Math.PI,
			-Math.PI / 2,
			false
		)
		context.arc(
			offset.x + arrowWidth + Math.round(toolTipWidth) - radius,
			offset.y + radius,
			radius,
			-Math.PI / 2,
			0,
			false
		)
		context.arc(
			offset.x + arrowWidth + Math.round(toolTipWidth) - radius,
			offset.y + toolTipHeight - radius,
			radius,
			0,
			Math.PI / 2,
			false
		)
		context.arc(
			offset.x + arrowWidth + radius,
			offset.y + toolTipHeight - radius,
			radius,
			Math.PI / 2,
			Math.PI,
			false
		)
		if (toolTipOption.showArrow) {
			context.lineTo(
				offset.x + arrowWidth,
				offset.y + 10 * opts.pix + 5 * opts.pix
			)
			context.lineTo(offset.x, offset.y + 10 * opts.pix)
		}
	}
	context.closePath()
	context.fill()
	if (toolTipOption.borderWidth > 0) {
		context.stroke()
	}
	// draw legend
	if (toolTipOption.legendShow) {
		textList.forEach(function (item, index) {
			if (item.color !== null) {
				context.beginPath()
				context.setFillStyle(item.color)
				var startX = offset.x + arrowWidth + 2 * boxPadding
				var startY =
					offset.y +
					(lineHeight - fontSize) / 2 +
					lineHeight * index +
					boxPadding +
					1
				if (isOverRightBorder) {
					startX =
						offset.x - toolTipWidth - arrowWidth + 2 * boxPadding
				}
				switch (item.legendShape) {
					case 'line':
						context.moveTo(
							startX,
							startY + 0.5 * legendWidth - 2 * opts.pix
						)
						context.fillRect(
							startX,
							startY + 0.5 * legendWidth - 2 * opts.pix,
							legendWidth,
							4 * opts.pix
						)
						break
					case 'triangle':
						context.moveTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						context.lineTo(
							startX + 2.5 * opts.pix,
							startY + 0.5 * legendWidth + 5 * opts.pix
						)
						context.lineTo(
							startX + 12.5 * opts.pix,
							startY + 0.5 * legendWidth + 5 * opts.pix
						)
						context.lineTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						break
					case 'diamond':
						context.moveTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						context.lineTo(
							startX + 2.5 * opts.pix,
							startY + 0.5 * legendWidth
						)
						context.lineTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth + 5 * opts.pix
						)
						context.lineTo(
							startX + 12.5 * opts.pix,
							startY + 0.5 * legendWidth
						)
						context.lineTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						break
					case 'circle':
						context.moveTo(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth
						)
						context.arc(
							startX + 7.5 * opts.pix,
							startY + 0.5 * legendWidth,
							5 * opts.pix,
							0,
							2 * Math.PI
						)
						break
					case 'rect':
						context.moveTo(
							startX,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						context.fillRect(
							startX,
							startY + 0.5 * legendWidth - 5 * opts.pix,
							15 * opts.pix,
							10 * opts.pix
						)
						break
					case 'square':
						context.moveTo(
							startX + 2 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						context.fillRect(
							startX + 2 * opts.pix,
							startY + 0.5 * legendWidth - 5 * opts.pix,
							10 * opts.pix,
							10 * opts.pix
						)
						break
					default:
						context.moveTo(
							startX,
							startY + 0.5 * legendWidth - 5 * opts.pix
						)
						context.fillRect(
							startX,
							startY + 0.5 * legendWidth - 5 * opts.pix,
							15 * opts.pix,
							10 * opts.pix
						)
				}
				context.closePath()
				context.fill()
			}
		})
	}

	// draw text list
	textList.forEach(function (item, index) {
		var startX =
			offset.x +
			arrowWidth +
			2 * boxPadding +
			legendWidth +
			legendMarginRight
		if (isOverRightBorder) {
			startX =
				offset.x -
				toolTipWidth -
				arrowWidth +
				2 * boxPadding +
				legendWidth +
				legendMarginRight
		}
		var startY =
			offset.y +
			lineHeight * index +
			(lineHeight - fontSize) / 2 -
			1 +
			boxPadding +
			fontSize
		context.beginPath()
		context.setFontSize(fontSize)
		context.setTextBaseline('normal')
		context.setFillStyle(toolTipOption.fontColor)
		context.fillText(item.text, startX, startY)
		context.closePath()
		context.stroke()
	})
}

function drawColumnDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	let columnOption = assign(
		{},
		{
			type: 'group',
			width: eachSpacing / 2,
			meterBorder: 4,
			meterFillColor: '#FFFFFF',
			barBorderCircle: false,
			barBorderRadius: [],
			seriesGap: 2,
			linearType: 'none',
			linearOpacity: 1,
			customColor: [],
			colorStop: 0,
			labelPosition: 'outside',
		},
		opts.extra.column
	)
	let calPoints = []
	context.save()
	let leftNum = -2
	let rightNum = xAxisPoints.length + 2
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
		rightNum = leftNum + opts.xAxis.itemCount + 4
	}
	if (
		opts.tooltip &&
		opts.tooltip.textList &&
		opts.tooltip.textList.length &&
		process === 1
	) {
		drawToolTipSplitArea(
			opts.tooltip.offset.x,
			opts,
			config,
			context,
			eachSpacing
		)
	}
	columnOption.customColor = fillCustomColor(
		columnOption.linearType,
		columnOption.customColor,
		series,
		config
	)
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()

		// 计算0轴坐标
		let spacingValid = opts.height - opts.area[0] - opts.area[2]
		let zeroHeight = (spacingValid * (0 - minRange)) / (maxRange - minRange)
		let zeroPoints = opts.height - Math.round(zeroHeight) - opts.area[2]
		eachSeries.zeroPoints = zeroPoints
		var data = eachSeries.data
		switch (columnOption.type) {
			case 'group':
				var points = getColumnDataPoints(
					data,
					minRange,
					maxRange,
					xAxisPoints,
					eachSpacing,
					opts,
					config,
					zeroPoints,
					process
				)
				var tooltipPoints = getStackDataPoints(
					data,
					minRange,
					maxRange,
					xAxisPoints,
					eachSpacing,
					opts,
					config,
					seriesIndex,
					series,
					process
				)
				calPoints.push(tooltipPoints)
				points = fixColumeData(
					points,
					eachSpacing,
					series.length,
					seriesIndex,
					config,
					opts
				)
				for (let i = 0; i < points.length; i++) {
					let item = points[i]
					//fix issues/I27B1N yyoinge & Joeshu
					if (item !== null && i > leftNum && i < rightNum) {
						var startX = item.x - item.width / 2
						var height = opts.height - item.y - opts.area[2]
						context.beginPath()
						var fillColor = item.color || eachSeries.color
						var strokeColor = item.color || eachSeries.color
						if (columnOption.linearType !== 'none') {
							var grd = context.createLinearGradient(
								startX,
								item.y,
								startX,
								zeroPoints
							)
							//透明渐变
							if (columnOption.linearType == 'opacity') {
								grd.addColorStop(
									0,
									hexToRgb(
										fillColor,
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(1, hexToRgb(fillColor, 1))
							} else {
								grd.addColorStop(
									0,
									hexToRgb(
										columnOption.customColor[
											eachSeries.linearIndex
										],
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(
									columnOption.colorStop,
									hexToRgb(
										columnOption.customColor[
											eachSeries.linearIndex
										],
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(1, hexToRgb(fillColor, 1))
							}
							fillColor = grd
						}
						// 圆角边框
						if (
							(columnOption.barBorderRadius &&
								columnOption.barBorderRadius.length === 4) ||
							columnOption.barBorderCircle === true
						) {
							const left = startX
							const top =
								item.y > zeroPoints ? zeroPoints : item.y
							const width = item.width
							const height = Math.abs(zeroPoints - item.y)
							if (columnOption.barBorderCircle) {
								columnOption.barBorderRadius = [
									width / 2,
									width / 2,
									0,
									0,
								]
							}
							if (item.y > zeroPoints) {
								columnOption.barBorderRadius = [
									0,
									0,
									width / 2,
									width / 2,
								]
							}
							let [r0, r1, r2, r3] = columnOption.barBorderRadius
							let minRadius = Math.min(width / 2, height / 2)
							r0 = r0 > minRadius ? minRadius : r0
							r1 = r1 > minRadius ? minRadius : r1
							r2 = r2 > minRadius ? minRadius : r2
							r3 = r3 > minRadius ? minRadius : r3
							r0 = r0 < 0 ? 0 : r0
							r1 = r1 < 0 ? 0 : r1
							r2 = r2 < 0 ? 0 : r2
							r3 = r3 < 0 ? 0 : r3
							context.arc(
								left + r0,
								top + r0,
								r0,
								-Math.PI,
								-Math.PI / 2
							)
							context.arc(
								left + width - r1,
								top + r1,
								r1,
								-Math.PI / 2,
								0
							)
							context.arc(
								left + width - r2,
								top + height - r2,
								r2,
								0,
								Math.PI / 2
							)
							context.arc(
								left + r3,
								top + height - r3,
								r3,
								Math.PI / 2,
								Math.PI
							)
						} else {
							context.moveTo(startX, item.y)
							context.lineTo(startX + item.width, item.y)
							context.lineTo(startX + item.width, zeroPoints)
							context.lineTo(startX, zeroPoints)
							context.lineTo(startX, item.y)
							context.setLineWidth(1)
							context.setStrokeStyle(strokeColor)
						}
						context.setFillStyle(fillColor)
						context.closePath()
						//context.stroke();
						context.fill()
					}
				}
				break
			case 'stack':
				// 绘制堆叠数据图
				var points = getStackDataPoints(
					data,
					minRange,
					maxRange,
					xAxisPoints,
					eachSpacing,
					opts,
					config,
					seriesIndex,
					series,
					process
				)
				calPoints.push(points)
				points = fixColumeStackData(
					points,
					eachSpacing,
					series.length,
					seriesIndex,
					config,
					opts,
					series
				)
				for (let i = 0; i < points.length; i++) {
					let item = points[i]
					if (item !== null && i > leftNum && i < rightNum) {
						context.beginPath()
						var fillColor = item.color || eachSeries.color
						var startX = item.x - item.width / 2 + 1
						var height = opts.height - item.y - opts.area[2]
						var height0 = opts.height - item.y0 - opts.area[2]
						if (seriesIndex > 0) {
							height -= height0
						}
						context.setFillStyle(fillColor)
						context.moveTo(startX, item.y)
						context.fillRect(startX, item.y, item.width, height)
						context.closePath()
						context.fill()
					}
				}
				break
			case 'meter':
				// 绘制温度计数据图
				var points = getDataPoints(
					data,
					minRange,
					maxRange,
					xAxisPoints,
					eachSpacing,
					opts,
					config,
					process
				)
				calPoints.push(points)
				points = fixColumeMeterData(
					points,
					eachSpacing,
					series.length,
					seriesIndex,
					config,
					opts,
					columnOption.meterBorder
				)
				for (let i = 0; i < points.length; i++) {
					let item = points[i]
					if (item !== null && i > leftNum && i < rightNum) {
						//画背景颜色
						context.beginPath()
						if (seriesIndex == 0 && columnOption.meterBorder > 0) {
							context.setStrokeStyle(eachSeries.color)
							context.setLineWidth(
								columnOption.meterBorder * opts.pix
							)
						}
						if (seriesIndex == 0) {
							context.setFillStyle(columnOption.meterFillColor)
						} else {
							context.setFillStyle(item.color || eachSeries.color)
						}
						var startX = item.x - item.width / 2
						var height = opts.height - item.y - opts.area[2]
						if (
							(columnOption.barBorderRadius &&
								columnOption.barBorderRadius.length === 4) ||
							columnOption.barBorderCircle === true
						) {
							const left = startX
							const top = item.y
							const width = item.width
							const height = zeroPoints - item.y
							if (columnOption.barBorderCircle) {
								columnOption.barBorderRadius = [
									width / 2,
									width / 2,
									0,
									0,
								]
							}
							let [r0, r1, r2, r3] = columnOption.barBorderRadius
							let minRadius = Math.min(width / 2, height / 2)
							r0 = r0 > minRadius ? minRadius : r0
							r1 = r1 > minRadius ? minRadius : r1
							r2 = r2 > minRadius ? minRadius : r2
							r3 = r3 > minRadius ? minRadius : r3
							r0 = r0 < 0 ? 0 : r0
							r1 = r1 < 0 ? 0 : r1
							r2 = r2 < 0 ? 0 : r2
							r3 = r3 < 0 ? 0 : r3
							context.arc(
								left + r0,
								top + r0,
								r0,
								-Math.PI,
								-Math.PI / 2
							)
							context.arc(
								left + width - r1,
								top + r1,
								r1,
								-Math.PI / 2,
								0
							)
							context.arc(
								left + width - r2,
								top + height - r2,
								r2,
								0,
								Math.PI / 2
							)
							context.arc(
								left + r3,
								top + height - r3,
								r3,
								Math.PI / 2,
								Math.PI
							)
							context.fill()
						} else {
							context.moveTo(startX, item.y)
							context.lineTo(startX + item.width, item.y)
							context.lineTo(startX + item.width, zeroPoints)
							context.lineTo(startX, zeroPoints)
							context.lineTo(startX, item.y)
							context.fill()
						}
						if (seriesIndex == 0 && columnOption.meterBorder > 0) {
							context.closePath()
							context.stroke()
						}
					}
				}
				break
		}
	})

	if (opts.dataLabel !== false && process === 1) {
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			switch (columnOption.type) {
				case 'group':
					var points = getColumnDataPoints(
						data,
						minRange,
						maxRange,
						xAxisPoints,
						eachSpacing,
						opts,
						config,
						process
					)
					points = fixColumeData(
						points,
						eachSpacing,
						series.length,
						seriesIndex,
						config,
						opts
					)
					drawColumePointText(
						points,
						eachSeries,
						config,
						context,
						opts
					)
					break
				case 'stack':
					var points = getStackDataPoints(
						data,
						minRange,
						maxRange,
						xAxisPoints,
						eachSpacing,
						opts,
						config,
						seriesIndex,
						series,
						process
					)
					drawColumePointText(
						points,
						eachSeries,
						config,
						context,
						opts
					)
					break
				case 'meter':
					var points = getDataPoints(
						data,
						minRange,
						maxRange,
						xAxisPoints,
						eachSpacing,
						opts,
						config,
						process
					)
					drawColumePointText(
						points,
						eachSeries,
						config,
						context,
						opts
					)
					break
			}
		})
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawMountDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	let mountOption = assign(
		{},
		{
			type: 'mount',
			widthRatio: 1,
			borderWidth: 1,
			barBorderCircle: false,
			barBorderRadius: [],
			linearType: 'none',
			linearOpacity: 1,
			customColor: [],
			colorStop: 0,
		},
		opts.extra.mount
	)
	mountOption.widthRatio =
		mountOption.widthRatio <= 0 ? 0 : mountOption.widthRatio
	mountOption.widthRatio =
		mountOption.widthRatio >= 2 ? 2 : mountOption.widthRatio
	let calPoints = []
	context.save()
	let leftNum = -2
	let rightNum = xAxisPoints.length + 2
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
		rightNum = leftNum + opts.xAxis.itemCount + 4
	}
	mountOption.customColor = fillCustomColor(
		mountOption.linearType,
		mountOption.customColor,
		series,
		config
	)
	let ranges, minRange, maxRange
	ranges = [].concat(opts.chartData.yAxisData.ranges[0])
	minRange = ranges.pop()
	maxRange = ranges.shift()

	// 计算0轴坐标
	let spacingValid = opts.height - opts.area[0] - opts.area[2]
	let zeroHeight = (spacingValid * (0 - minRange)) / (maxRange - minRange)
	let zeroPoints = opts.height - Math.round(zeroHeight) - opts.area[2]

	var points = getMountDataPoints(
		series,
		minRange,
		maxRange,
		xAxisPoints,
		eachSpacing,
		opts,
		mountOption,
		zeroPoints,
		process
	)
	switch (mountOption.type) {
		case 'bar':
			for (let i = 0; i < points.length; i++) {
				let item = points[i]
				if (item !== null && i > leftNum && i < rightNum) {
					var startX =
						item.x - (eachSpacing * mountOption.widthRatio) / 2
					var height = opts.height - item.y - opts.area[2]
					context.beginPath()
					var fillColor = item.color || series[i].color
					var strokeColor = item.color || series[i].color
					if (mountOption.linearType !== 'none') {
						var grd = context.createLinearGradient(
							startX,
							item.y,
							startX,
							zeroPoints
						)
						//透明渐变
						if (mountOption.linearType == 'opacity') {
							grd.addColorStop(
								0,
								hexToRgb(fillColor, mountOption.linearOpacity)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						} else {
							grd.addColorStop(
								0,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(
								mountOption.colorStop,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						}
						fillColor = grd
					}
					// 圆角边框
					if (
						(mountOption.barBorderRadius &&
							mountOption.barBorderRadius.length === 4) ||
						mountOption.barBorderCircle === true
					) {
						const left = startX
						const top = item.y > zeroPoints ? zeroPoints : item.y
						const width = item.width
						const height = Math.abs(zeroPoints - item.y)
						if (mountOption.barBorderCircle) {
							mountOption.barBorderRadius = [
								width / 2,
								width / 2,
								0,
								0,
							]
						}
						if (item.y > zeroPoints) {
							mountOption.barBorderRadius = [
								0,
								0,
								width / 2,
								width / 2,
							]
						}
						let [r0, r1, r2, r3] = mountOption.barBorderRadius
						let minRadius = Math.min(width / 2, height / 2)
						r0 = r0 > minRadius ? minRadius : r0
						r1 = r1 > minRadius ? minRadius : r1
						r2 = r2 > minRadius ? minRadius : r2
						r3 = r3 > minRadius ? minRadius : r3
						r0 = r0 < 0 ? 0 : r0
						r1 = r1 < 0 ? 0 : r1
						r2 = r2 < 0 ? 0 : r2
						r3 = r3 < 0 ? 0 : r3
						context.arc(
							left + r0,
							top + r0,
							r0,
							-Math.PI,
							-Math.PI / 2
						)
						context.arc(
							left + width - r1,
							top + r1,
							r1,
							-Math.PI / 2,
							0
						)
						context.arc(
							left + width - r2,
							top + height - r2,
							r2,
							0,
							Math.PI / 2
						)
						context.arc(
							left + r3,
							top + height - r3,
							r3,
							Math.PI / 2,
							Math.PI
						)
					} else {
						context.moveTo(startX, item.y)
						context.lineTo(startX + item.width, item.y)
						context.lineTo(startX + item.width, zeroPoints)
						context.lineTo(startX, zeroPoints)
						context.lineTo(startX, item.y)
					}
					context.setStrokeStyle(strokeColor)
					context.setFillStyle(fillColor)
					if (mountOption.borderWidth > 0) {
						context.setLineWidth(mountOption.borderWidth * opts.pix)
						context.closePath()
						context.stroke()
					}
					context.fill()
				}
			}
			break
		case 'triangle':
			for (let i = 0; i < points.length; i++) {
				let item = points[i]
				if (item !== null && i > leftNum && i < rightNum) {
					var startX =
						item.x - (eachSpacing * mountOption.widthRatio) / 2
					var height = opts.height - item.y - opts.area[2]
					context.beginPath()
					var fillColor = item.color || series[i].color
					var strokeColor = item.color || series[i].color
					if (mountOption.linearType !== 'none') {
						var grd = context.createLinearGradient(
							startX,
							item.y,
							startX,
							zeroPoints
						)
						//透明渐变
						if (mountOption.linearType == 'opacity') {
							grd.addColorStop(
								0,
								hexToRgb(fillColor, mountOption.linearOpacity)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						} else {
							grd.addColorStop(
								0,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(
								mountOption.colorStop,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						}
						fillColor = grd
					}
					context.moveTo(startX, zeroPoints)
					context.lineTo(item.x, item.y)
					context.lineTo(startX + item.width, zeroPoints)
					context.setStrokeStyle(strokeColor)
					context.setFillStyle(fillColor)
					if (mountOption.borderWidth > 0) {
						context.setLineWidth(mountOption.borderWidth * opts.pix)
						context.stroke()
					}
					context.fill()
				}
			}
			break
		case 'mount':
			for (let i = 0; i < points.length; i++) {
				let item = points[i]
				if (item !== null && i > leftNum && i < rightNum) {
					var startX =
						item.x - (eachSpacing * mountOption.widthRatio) / 2
					var height = opts.height - item.y - opts.area[2]
					context.beginPath()
					var fillColor = item.color || series[i].color
					var strokeColor = item.color || series[i].color
					if (mountOption.linearType !== 'none') {
						var grd = context.createLinearGradient(
							startX,
							item.y,
							startX,
							zeroPoints
						)
						//透明渐变
						if (mountOption.linearType == 'opacity') {
							grd.addColorStop(
								0,
								hexToRgb(fillColor, mountOption.linearOpacity)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						} else {
							grd.addColorStop(
								0,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(
								mountOption.colorStop,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						}
						fillColor = grd
					}
					context.moveTo(startX, zeroPoints)
					context.bezierCurveTo(
						item.x - item.width / 4,
						zeroPoints,
						item.x - item.width / 4,
						item.y,
						item.x,
						item.y
					)
					context.bezierCurveTo(
						item.x + item.width / 4,
						item.y,
						item.x + item.width / 4,
						zeroPoints,
						startX + item.width,
						zeroPoints
					)
					context.setStrokeStyle(strokeColor)
					context.setFillStyle(fillColor)
					if (mountOption.borderWidth > 0) {
						context.setLineWidth(mountOption.borderWidth * opts.pix)
						context.stroke()
					}
					context.fill()
				}
			}
			break
		case 'sharp':
			for (let i = 0; i < points.length; i++) {
				let item = points[i]
				if (item !== null && i > leftNum && i < rightNum) {
					var startX =
						item.x - (eachSpacing * mountOption.widthRatio) / 2
					var height = opts.height - item.y - opts.area[2]
					context.beginPath()
					var fillColor = item.color || series[i].color
					var strokeColor = item.color || series[i].color
					if (mountOption.linearType !== 'none') {
						var grd = context.createLinearGradient(
							startX,
							item.y,
							startX,
							zeroPoints
						)
						//透明渐变
						if (mountOption.linearType == 'opacity') {
							grd.addColorStop(
								0,
								hexToRgb(fillColor, mountOption.linearOpacity)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						} else {
							grd.addColorStop(
								0,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(
								mountOption.colorStop,
								hexToRgb(
									mountOption.customColor[
										series[i].linearIndex
									],
									mountOption.linearOpacity
								)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						}
						fillColor = grd
					}
					context.moveTo(startX, zeroPoints)
					context.quadraticCurveTo(
						item.x - 0,
						zeroPoints - height / 4,
						item.x,
						item.y
					)
					context.quadraticCurveTo(
						item.x + 0,
						zeroPoints - height / 4,
						startX + item.width,
						zeroPoints
					)
					context.setStrokeStyle(strokeColor)
					context.setFillStyle(fillColor)
					if (mountOption.borderWidth > 0) {
						context.setLineWidth(mountOption.borderWidth * opts.pix)
						context.stroke()
					}
					context.fill()
				}
			}
			break
	}

	if (opts.dataLabel !== false && process === 1) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[0])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var points = getMountDataPoints(
			series,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			mountOption,
			zeroPoints,
			process
		)
		drawMountPointText(points, series, config, context, opts, zeroPoints)
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: points,
		eachSpacing: eachSpacing,
	}
}

function drawBarDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let yAxisPoints = []
	let eachSpacing =
		(opts.height - opts.area[0] - opts.area[2]) / opts.categories.length
	for (let i = 0; i < opts.categories.length; i++) {
		yAxisPoints.push(opts.area[0] + eachSpacing / 2 + eachSpacing * i)
	}
	let columnOption = assign(
		{},
		{
			type: 'group',
			width: eachSpacing / 2,
			meterBorder: 4,
			meterFillColor: '#FFFFFF',
			barBorderCircle: false,
			barBorderRadius: [],
			seriesGap: 2,
			linearType: 'none',
			linearOpacity: 1,
			customColor: [],
			colorStop: 0,
		},
		opts.extra.bar
	)
	let calPoints = []
	context.save()
	let leftNum = -2
	let rightNum = yAxisPoints.length + 2
	if (
		opts.tooltip &&
		opts.tooltip.textList &&
		opts.tooltip.textList.length &&
		process === 1
	) {
		drawBarToolTipSplitArea(
			opts.tooltip.offset.y,
			opts,
			config,
			context,
			eachSpacing
		)
	}
	columnOption.customColor = fillCustomColor(
		columnOption.linearType,
		columnOption.customColor,
		series,
		config
	)
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.xAxisData.ranges)
		maxRange = ranges.pop()
		minRange = ranges.shift()
		var data = eachSeries.data
		switch (columnOption.type) {
			case 'group':
				var points = getBarDataPoints(
					data,
					minRange,
					maxRange,
					yAxisPoints,
					eachSpacing,
					opts,
					config,
					process
				)
				var tooltipPoints = getBarStackDataPoints(
					data,
					minRange,
					maxRange,
					yAxisPoints,
					eachSpacing,
					opts,
					config,
					seriesIndex,
					series,
					process
				)
				calPoints.push(tooltipPoints)
				points = fixBarData(
					points,
					eachSpacing,
					series.length,
					seriesIndex,
					config,
					opts
				)
				for (let i = 0; i < points.length; i++) {
					let item = points[i]
					//fix issues/I27B1N yyoinge & Joeshu
					if (item !== null && i > leftNum && i < rightNum) {
						//var startX = item.x - item.width / 2;
						var startX = opts.area[3]
						var startY = item.y - item.width / 2
						var height = item.height
						context.beginPath()
						var fillColor = item.color || eachSeries.color
						var strokeColor = item.color || eachSeries.color
						if (columnOption.linearType !== 'none') {
							var grd = context.createLinearGradient(
								startX,
								item.y,
								item.x,
								item.y
							)
							//透明渐变
							if (columnOption.linearType == 'opacity') {
								grd.addColorStop(
									0,
									hexToRgb(
										fillColor,
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(1, hexToRgb(fillColor, 1))
							} else {
								grd.addColorStop(
									0,
									hexToRgb(
										columnOption.customColor[
											eachSeries.linearIndex
										],
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(
									columnOption.colorStop,
									hexToRgb(
										columnOption.customColor[
											eachSeries.linearIndex
										],
										columnOption.linearOpacity
									)
								)
								grd.addColorStop(1, hexToRgb(fillColor, 1))
							}
							fillColor = grd
						}
						// 圆角边框
						if (
							(columnOption.barBorderRadius &&
								columnOption.barBorderRadius.length === 4) ||
							columnOption.barBorderCircle === true
						) {
							const left = startX
							const width = item.width
							const top = item.y - item.width / 2
							const height = item.height
							if (columnOption.barBorderCircle) {
								columnOption.barBorderRadius = [
									width / 2,
									width / 2,
									0,
									0,
								]
							}
							let [r0, r1, r2, r3] = columnOption.barBorderRadius
							let minRadius = Math.min(width / 2, height / 2)
							r0 = r0 > minRadius ? minRadius : r0
							r1 = r1 > minRadius ? minRadius : r1
							r2 = r2 > minRadius ? minRadius : r2
							r3 = r3 > minRadius ? minRadius : r3
							r0 = r0 < 0 ? 0 : r0
							r1 = r1 < 0 ? 0 : r1
							r2 = r2 < 0 ? 0 : r2
							r3 = r3 < 0 ? 0 : r3

							context.arc(
								left + r3,
								top + r3,
								r3,
								-Math.PI,
								-Math.PI / 2
							)
							context.arc(
								item.x - r0,
								top + r0,
								r0,
								-Math.PI / 2,
								0
							)
							context.arc(
								item.x - r1,
								top + width - r1,
								r1,
								0,
								Math.PI / 2
							)
							context.arc(
								left + r2,
								top + width - r2,
								r2,
								Math.PI / 2,
								Math.PI
							)
						} else {
							context.moveTo(startX, startY)
							context.lineTo(item.x, startY)
							context.lineTo(item.x, startY + item.width)
							context.lineTo(startX, startY + item.width)
							context.lineTo(startX, startY)
							context.setLineWidth(1)
							context.setStrokeStyle(strokeColor)
						}
						context.setFillStyle(fillColor)
						context.closePath()
						//context.stroke();
						context.fill()
					}
				}
				break
			case 'stack':
				// 绘制堆叠数据图
				var points = getBarStackDataPoints(
					data,
					minRange,
					maxRange,
					yAxisPoints,
					eachSpacing,
					opts,
					config,
					seriesIndex,
					series,
					process
				)
				calPoints.push(points)
				points = fixBarStackData(
					points,
					eachSpacing,
					series.length,
					seriesIndex,
					config,
					opts,
					series
				)
				for (let i = 0; i < points.length; i++) {
					let item = points[i]
					if (item !== null && i > leftNum && i < rightNum) {
						context.beginPath()
						var fillColor = item.color || eachSeries.color
						var startX = item.x0
						context.setFillStyle(fillColor)
						context.moveTo(startX, item.y - item.width / 2)
						context.fillRect(
							startX,
							item.y - item.width / 2,
							item.height,
							item.width
						)
						context.closePath()
						context.fill()
					}
				}
				break
		}
	})

	if (opts.dataLabel !== false && process === 1) {
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(opts.chartData.xAxisData.ranges)
			maxRange = ranges.pop()
			minRange = ranges.shift()
			var data = eachSeries.data
			switch (columnOption.type) {
				case 'group':
					var points = getBarDataPoints(
						data,
						minRange,
						maxRange,
						yAxisPoints,
						eachSpacing,
						opts,
						config,
						process
					)
					points = fixBarData(
						points,
						eachSpacing,
						series.length,
						seriesIndex,
						config,
						opts
					)
					drawBarPointText(points, eachSeries, config, context, opts)
					break
				case 'stack':
					var points = getBarStackDataPoints(
						data,
						minRange,
						maxRange,
						yAxisPoints,
						eachSpacing,
						opts,
						config,
						seriesIndex,
						series,
						process
					)
					drawBarPointText(points, eachSeries, config, context, opts)
					break
			}
		})
	}
	return {
		yAxisPoints: yAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawCandleDataPoints(series, seriesMA, opts, config, context) {
	var process =
		arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
	var candleOption = assign(
		{},
		{
			color: {},
			average: {},
		},
		opts.extra.candle
	)
	candleOption.color = assign(
		{},
		{
			upLine: '#f04864',
			upFill: '#f04864',
			downLine: '#2fc25b',
			downFill: '#2fc25b',
		},
		candleOption.color
	)
	candleOption.average = assign(
		{},
		{
			show: false,
			name: [],
			day: [],
			color: config.color,
		},
		candleOption.average
	)
	opts.extra.candle = candleOption
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	let calPoints = []
	context.save()
	let leftNum = -2
	let rightNum = xAxisPoints.length + 2
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
		rightNum = leftNum + opts.xAxis.itemCount + 4
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	//画均线
	if (candleOption.average.show || seriesMA) {
		//Merge pull request !12 from 邱贵翔
		seriesMA.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			var points = getDataPoints(
				data,
				minRange,
				maxRange,
				xAxisPoints,
				eachSpacing,
				opts,
				config,
				process
			)
			var splitPointList = splitPoints(points, eachSeries)
			for (let i = 0; i < splitPointList.length; i++) {
				let points = splitPointList[i]
				context.beginPath()
				context.setStrokeStyle(eachSeries.color)
				context.setLineWidth(1)
				if (points.length === 1) {
					context.moveTo(points[0].x, points[0].y)
					context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI)
				} else {
					context.moveTo(points[0].x, points[0].y)
					let startPoint = 0
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							var ctrlPoint = createCurveControlPoints(
								points,
								j - 1
							)
							context.bezierCurveTo(
								ctrlPoint.ctrA.x,
								ctrlPoint.ctrA.y,
								ctrlPoint.ctrB.x,
								ctrlPoint.ctrB.y,
								item.x,
								item.y
							)
						}
					}
					context.moveTo(points[0].x, points[0].y)
				}
				context.closePath()
				context.stroke()
			}
		})
	}
	//画K线
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var data = eachSeries.data
		var points = getCandleDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			process
		)
		calPoints.push(points)
		var splitPointList = splitPoints(points, eachSeries)
		for (let i = 0; i < splitPointList[0].length; i++) {
			if (i > leftNum && i < rightNum) {
				let item = splitPointList[0][i]
				context.beginPath()
				//如果上涨
				if (data[i][1] - data[i][0] > 0) {
					context.setStrokeStyle(candleOption.color.upLine)
					context.setFillStyle(candleOption.color.upFill)
					context.setLineWidth(1 * opts.pix)
					context.moveTo(item[3].x, item[3].y) //顶点
					context.lineTo(item[1].x, item[1].y) //收盘中间点
					context.lineTo(item[1].x - eachSpacing / 4, item[1].y) //收盘左侧点
					context.lineTo(item[0].x - eachSpacing / 4, item[0].y) //开盘左侧点
					context.lineTo(item[0].x, item[0].y) //开盘中间点
					context.lineTo(item[2].x, item[2].y) //底点
					context.lineTo(item[0].x, item[0].y) //开盘中间点
					context.lineTo(item[0].x + eachSpacing / 4, item[0].y) //开盘右侧点
					context.lineTo(item[1].x + eachSpacing / 4, item[1].y) //收盘右侧点
					context.lineTo(item[1].x, item[1].y) //收盘中间点
					context.moveTo(item[3].x, item[3].y) //顶点
				} else {
					context.setStrokeStyle(candleOption.color.downLine)
					context.setFillStyle(candleOption.color.downFill)
					context.setLineWidth(1 * opts.pix)
					context.moveTo(item[3].x, item[3].y) //顶点
					context.lineTo(item[0].x, item[0].y) //开盘中间点
					context.lineTo(item[0].x - eachSpacing / 4, item[0].y) //开盘左侧点
					context.lineTo(item[1].x - eachSpacing / 4, item[1].y) //收盘左侧点
					context.lineTo(item[1].x, item[1].y) //收盘中间点
					context.lineTo(item[2].x, item[2].y) //底点
					context.lineTo(item[1].x, item[1].y) //收盘中间点
					context.lineTo(item[1].x + eachSpacing / 4, item[1].y) //收盘右侧点
					context.lineTo(item[0].x + eachSpacing / 4, item[0].y) //开盘右侧点
					context.lineTo(item[0].x, item[0].y) //开盘中间点
					context.moveTo(item[3].x, item[3].y) //顶点
				}
				context.closePath()
				context.fill()
				context.stroke()
			}
		}
	})
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawAreaDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var areaOption = assign(
		{},
		{
			type: 'straight',
			opacity: 0.2,
			addLine: false,
			width: 2,
			gradient: false,
			activeType: 'none',
		},
		opts.extra.area
	)
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	let endY = opts.height - opts.area[2]
	let calPoints = []
	context.save()
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		let data = eachSeries.data
		let points = getDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			process
		)
		calPoints.push(points)
		let splitPointList = splitPoints(points, eachSeries)
		for (let i = 0; i < splitPointList.length; i++) {
			let points = splitPointList[i]
			// 绘制区域数
			context.beginPath()
			context.setStrokeStyle(
				hexToRgb(eachSeries.color, areaOption.opacity)
			)
			if (areaOption.gradient) {
				let gradient = context.createLinearGradient(
					0,
					opts.area[0],
					0,
					opts.height - opts.area[2]
				)
				gradient.addColorStop(
					'0',
					hexToRgb(eachSeries.color, areaOption.opacity)
				)
				gradient.addColorStop('1.0', hexToRgb('#FFFFFF', 0.1))
				context.setFillStyle(gradient)
			} else {
				context.setFillStyle(
					hexToRgb(eachSeries.color, areaOption.opacity)
				)
			}
			context.setLineWidth(areaOption.width * opts.pix)
			if (points.length > 1) {
				let firstPoint = points[0]
				let lastPoint = points[points.length - 1]
				context.moveTo(firstPoint.x, firstPoint.y)
				let startPoint = 0
				if (areaOption.type === 'curve') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							let ctrlPoint = createCurveControlPoints(
								points,
								j - 1
							)
							context.bezierCurveTo(
								ctrlPoint.ctrA.x,
								ctrlPoint.ctrA.y,
								ctrlPoint.ctrB.x,
								ctrlPoint.ctrB.y,
								item.x,
								item.y
							)
						}
					}
				}
				if (areaOption.type === 'straight') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							context.lineTo(item.x, item.y)
						}
					}
				}
				if (areaOption.type === 'step') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							context.lineTo(item.x, points[j - 1].y)
							context.lineTo(item.x, item.y)
						}
					}
				}
				context.lineTo(lastPoint.x, endY)
				context.lineTo(firstPoint.x, endY)
				context.lineTo(firstPoint.x, firstPoint.y)
			} else {
				let item = points[0]
				context.moveTo(item.x - eachSpacing / 2, item.y)
				// context.lineTo(item.x + eachSpacing / 2, item.y);
				// context.lineTo(item.x + eachSpacing / 2, endY);
				// context.lineTo(item.x - eachSpacing / 2, endY);
				// context.moveTo(item.x - eachSpacing / 2, item.y);
			}
			context.closePath()
			context.fill()
			//画连线
			if (areaOption.addLine) {
				if (eachSeries.lineType == 'dash') {
					let dashLength = eachSeries.dashLength
						? eachSeries.dashLength
						: 8
					dashLength *= opts.pix
					context.setLineDash([dashLength, dashLength])
				}
				context.beginPath()
				context.setStrokeStyle(eachSeries.color)
				context.setLineWidth(areaOption.width * opts.pix)
				if (points.length === 1) {
					context.moveTo(points[0].x, points[0].y)
					// context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
				} else {
					context.moveTo(points[0].x, points[0].y)
					let startPoint = 0
					if (areaOption.type === 'curve') {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								let ctrlPoint = createCurveControlPoints(
									points,
									j - 1
								)
								context.bezierCurveTo(
									ctrlPoint.ctrA.x,
									ctrlPoint.ctrA.y,
									ctrlPoint.ctrB.x,
									ctrlPoint.ctrB.y,
									item.x,
									item.y
								)
							}
						}
					}
					if (areaOption.type === 'straight') {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								context.lineTo(item.x, item.y)
							}
						}
					}
					if (areaOption.type === 'step') {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								context.lineTo(item.x, points[j - 1].y)
								context.lineTo(item.x, item.y)
							}
						}
					}
					context.moveTo(points[0].x, points[0].y)
				}
				context.stroke()
				context.setLineDash([])
			}
		}
		//画点
		if (opts.dataPointShape !== false) {
			drawPointShape(
				points,
				eachSeries.color,
				eachSeries.pointShape,
				context,
				opts
			)
		}
		drawActivePoint(
			points,
			eachSeries.color,
			eachSeries.pointShape,
			context,
			opts,
			areaOption,
			seriesIndex
		)
	})

	if (opts.dataLabel !== false && process === 1) {
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			var points = getDataPoints(
				data,
				minRange,
				maxRange,
				xAxisPoints,
				eachSpacing,
				opts,
				config,
				process
			)
			drawPointText(points, eachSeries, config, context, opts)
		})
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawScatterDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var scatterOption = assign(
		{},
		{
			type: 'circle',
		},
		opts.extra.scatter
	)
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	var calPoints = []
	context.save()
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var data = eachSeries.data
		var points = getDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			process
		)
		context.beginPath()
		context.setStrokeStyle(eachSeries.color)
		context.setFillStyle(eachSeries.color)
		context.setLineWidth(1 * opts.pix)
		var shape = eachSeries.pointShape
		if (shape === 'diamond') {
			points.forEach(function (item, index) {
				if (item !== null) {
					context.moveTo(item.x, item.y - 4.5)
					context.lineTo(item.x - 4.5, item.y)
					context.lineTo(item.x, item.y + 4.5)
					context.lineTo(item.x + 4.5, item.y)
					context.lineTo(item.x, item.y - 4.5)
				}
			})
		} else if (shape === 'circle') {
			points.forEach(function (item, index) {
				if (item !== null) {
					context.moveTo(item.x + 2.5 * opts.pix, item.y)
					context.arc(
						item.x,
						item.y,
						3 * opts.pix,
						0,
						2 * Math.PI,
						false
					)
				}
			})
		} else if (shape === 'square') {
			points.forEach(function (item, index) {
				if (item !== null) {
					context.moveTo(item.x - 3.5, item.y - 3.5)
					context.rect(item.x - 3.5, item.y - 3.5, 7, 7)
				}
			})
		} else if (shape === 'triangle') {
			points.forEach(function (item, index) {
				if (item !== null) {
					context.moveTo(item.x, item.y - 4.5)
					context.lineTo(item.x - 4.5, item.y + 4.5)
					context.lineTo(item.x + 4.5, item.y + 4.5)
					context.lineTo(item.x, item.y - 4.5)
				}
			})
		} else if (shape === 'triangle') {
			return
		}
		context.closePath()
		context.fill()
		context.stroke()
	})
	if (opts.dataLabel !== false && process === 1) {
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			var points = getDataPoints(
				data,
				minRange,
				maxRange,
				xAxisPoints,
				eachSpacing,
				opts,
				config,
				process
			)
			drawPointText(points, eachSeries, config, context, opts)
		})
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawBubbleDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var bubbleOption = assign(
		{},
		{
			opacity: 1,
			border: 2,
		},
		opts.extra.bubble
	)
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	var calPoints = []
	context.save()
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var data = eachSeries.data
		var points = getDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			process
		)
		context.beginPath()
		context.setStrokeStyle(eachSeries.color)
		context.setLineWidth(bubbleOption.border * opts.pix)
		context.setFillStyle(hexToRgb(eachSeries.color, bubbleOption.opacity))
		points.forEach(function (item, index) {
			context.moveTo(item.x + item.r, item.y)
			context.arc(
				item.x,
				item.y,
				item.r * opts.pix,
				0,
				2 * Math.PI,
				false
			)
		})
		context.closePath()
		context.fill()
		context.stroke()

		if (opts.dataLabel !== false && process === 1) {
			points.forEach(function (item, index) {
				context.beginPath()
				var fontSize = eachSeries.textSize * opts.pix || config.fontSize
				context.setFontSize(fontSize)
				context.setFillStyle(eachSeries.textColor || '#FFFFFF')
				context.setTextAlign('center')
				context.fillText(String(item.t), item.x, item.y + fontSize / 2)
				context.closePath()
				context.stroke()
				context.setTextAlign('left')
			})
		}
	})
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawLineDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var lineOption = assign(
		{},
		{
			type: 'straight',
			width: 2,
			activeType: 'none',
			linearType: 'none',
			onShadow: false,
			animation: 'vertical',
		},
		opts.extra.line
	)
	lineOption.width *= opts.pix
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	var calPoints = []
	context.save()
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	series.forEach(function (eachSeries, seriesIndex) {
		// 这段很神奇的代码用于解决ios16的setStrokeStyle失效的bug
		context.beginPath()
		context.setStrokeStyle(eachSeries.color)
		context.moveTo(-10000, -10000)
		context.lineTo(-10001, -10001)
		context.stroke()
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var data = eachSeries.data
		var points = getLineDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			lineOption,
			process
		)
		calPoints.push(points)
		var splitPointList = splitPoints(points, eachSeries)
		if (eachSeries.lineType == 'dash') {
			let dashLength = eachSeries.dashLength ? eachSeries.dashLength : 8
			dashLength *= opts.pix
			context.setLineDash([dashLength, dashLength])
		}
		context.beginPath()
		var strokeColor = eachSeries.color
		if (
			lineOption.linearType !== 'none' &&
			eachSeries.linearColor &&
			eachSeries.linearColor.length > 0
		) {
			var grd = context.createLinearGradient(
				opts.chartData.xAxisData.startX,
				opts.height / 2,
				opts.chartData.xAxisData.endX,
				opts.height / 2
			)
			for (var i = 0; i < eachSeries.linearColor.length; i++) {
				grd.addColorStop(
					eachSeries.linearColor[i][0],
					hexToRgb(eachSeries.linearColor[i][1], 1)
				)
			}
			strokeColor = grd
		}
		context.setStrokeStyle(strokeColor)
		if (
			lineOption.onShadow == true &&
			eachSeries.setShadow &&
			eachSeries.setShadow.length > 0
		) {
			context.setShadow(
				eachSeries.setShadow[0],
				eachSeries.setShadow[1],
				eachSeries.setShadow[2],
				eachSeries.setShadow[3]
			)
		} else {
			context.setShadow(0, 0, 0, 'rgba(0,0,0,0)')
		}
		context.setLineWidth(lineOption.width)
		splitPointList.forEach(function (points, index) {
			if (points.length === 1) {
				context.moveTo(points[0].x, points[0].y)
				// context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
			} else {
				context.moveTo(points[0].x, points[0].y)
				let startPoint = 0
				if (lineOption.type === 'curve') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							var ctrlPoint = createCurveControlPoints(
								points,
								j - 1
							)
							context.bezierCurveTo(
								ctrlPoint.ctrA.x,
								ctrlPoint.ctrA.y,
								ctrlPoint.ctrB.x,
								ctrlPoint.ctrB.y,
								item.x,
								item.y
							)
						}
					}
				}
				if (lineOption.type === 'straight') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							context.lineTo(item.x, item.y)
						}
					}
				}
				if (lineOption.type === 'step') {
					for (let j = 0; j < points.length; j++) {
						let item = points[j]
						if (startPoint == 0 && item.x > leftSpace) {
							context.moveTo(item.x, item.y)
							startPoint = 1
						}
						if (
							j > 0 &&
							item.x > leftSpace &&
							item.x < rightSpace
						) {
							context.lineTo(item.x, points[j - 1].y)
							context.lineTo(item.x, item.y)
						}
					}
				}
				context.moveTo(points[0].x, points[0].y)
			}
		})
		context.stroke()
		context.setLineDash([])
		if (opts.dataPointShape !== false) {
			drawPointShape(
				points,
				eachSeries.color,
				eachSeries.pointShape,
				context,
				opts
			)
		}
		drawActivePoint(
			points,
			eachSeries.color,
			eachSeries.pointShape,
			context,
			opts,
			lineOption
		)
	})
	if (opts.dataLabel !== false && process === 1) {
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			var points = getDataPoints(
				data,
				minRange,
				maxRange,
				xAxisPoints,
				eachSpacing,
				opts,
				config,
				process
			)
			drawPointText(points, eachSeries, config, context, opts)
		})
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawMixDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		eachSpacing = xAxisData.eachSpacing
	let columnOption = assign(
		{},
		{
			width: eachSpacing / 2,
			barBorderCircle: false,
			barBorderRadius: [],
			seriesGap: 2,
			linearType: 'none',
			linearOpacity: 1,
			customColor: [],
			colorStop: 0,
		},
		opts.extra.mix.column
	)
	let areaOption = assign(
		{},
		{
			opacity: 0.2,
			gradient: false,
		},
		opts.extra.mix.area
	)
	let lineOption = assign(
		{},
		{
			width: 2,
		},
		opts.extra.mix.line
	)
	let endY = opts.height - opts.area[2]
	let calPoints = []
	var columnIndex = 0
	var columnLength = 0
	series.forEach(function (eachSeries, seriesIndex) {
		if (eachSeries.type == 'column') {
			columnLength += 1
		}
	})
	context.save()
	let leftNum = -2
	let rightNum = xAxisPoints.length + 2
	let leftSpace = 0
	let rightSpace = opts.width + eachSpacing
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
		leftNum = Math.floor(-opts._scrollDistance_ / eachSpacing) - 2
		rightNum = leftNum + opts.xAxis.itemCount + 4
		leftSpace = -opts._scrollDistance_ - eachSpacing * 2 + opts.area[3]
		rightSpace = leftSpace + (opts.xAxis.itemCount + 4) * eachSpacing
	}
	columnOption.customColor = fillCustomColor(
		columnOption.linearType,
		columnOption.customColor,
		series,
		config
	)
	series.forEach(function (eachSeries, seriesIndex) {
		let ranges, minRange, maxRange
		ranges = [].concat(opts.chartData.yAxisData.ranges[eachSeries.index])
		minRange = ranges.pop()
		maxRange = ranges.shift()
		var data = eachSeries.data
		var points = getDataPoints(
			data,
			minRange,
			maxRange,
			xAxisPoints,
			eachSpacing,
			opts,
			config,
			process
		)
		calPoints.push(points)
		// 绘制柱状数据图
		if (eachSeries.type == 'column') {
			points = fixColumeData(
				points,
				eachSpacing,
				columnLength,
				columnIndex,
				config,
				opts
			)
			for (let i = 0; i < points.length; i++) {
				let item = points[i]
				if (item !== null && i > leftNum && i < rightNum) {
					var startX = item.x - item.width / 2
					var height = opts.height - item.y - opts.area[2]
					context.beginPath()
					var fillColor = item.color || eachSeries.color
					var strokeColor = item.color || eachSeries.color
					if (columnOption.linearType !== 'none') {
						var grd = context.createLinearGradient(
							startX,
							item.y,
							startX,
							opts.height - opts.area[2]
						)
						//透明渐变
						if (columnOption.linearType == 'opacity') {
							grd.addColorStop(
								0,
								hexToRgb(fillColor, columnOption.linearOpacity)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						} else {
							grd.addColorStop(
								0,
								hexToRgb(
									columnOption.customColor[
										eachSeries.linearIndex
									],
									columnOption.linearOpacity
								)
							)
							grd.addColorStop(
								columnOption.colorStop,
								hexToRgb(
									columnOption.customColor[
										eachSeries.linearIndex
									],
									columnOption.linearOpacity
								)
							)
							grd.addColorStop(1, hexToRgb(fillColor, 1))
						}
						fillColor = grd
					}
					// 圆角边框
					if (
						(columnOption.barBorderRadius &&
							columnOption.barBorderRadius.length === 4) ||
						columnOption.barBorderCircle
					) {
						const left = startX
						const top = item.y
						const width = item.width
						const height = opts.height - opts.area[2] - item.y
						if (columnOption.barBorderCircle) {
							columnOption.barBorderRadius = [
								width / 2,
								width / 2,
								0,
								0,
							]
						}
						let [r0, r1, r2, r3] = columnOption.barBorderRadius
						let minRadius = Math.min(width / 2, height / 2)
						r0 = r0 > minRadius ? minRadius : r0
						r1 = r1 > minRadius ? minRadius : r1
						r2 = r2 > minRadius ? minRadius : r2
						r3 = r3 > minRadius ? minRadius : r3
						r0 = r0 < 0 ? 0 : r0
						r1 = r1 < 0 ? 0 : r1
						r2 = r2 < 0 ? 0 : r2
						r3 = r3 < 0 ? 0 : r3
						context.arc(
							left + r0,
							top + r0,
							r0,
							-Math.PI,
							-Math.PI / 2
						)
						context.arc(
							left + width - r1,
							top + r1,
							r1,
							-Math.PI / 2,
							0
						)
						context.arc(
							left + width - r2,
							top + height - r2,
							r2,
							0,
							Math.PI / 2
						)
						context.arc(
							left + r3,
							top + height - r3,
							r3,
							Math.PI / 2,
							Math.PI
						)
					} else {
						context.moveTo(startX, item.y)
						context.lineTo(startX + item.width, item.y)
						context.lineTo(
							startX + item.width,
							opts.height - opts.area[2]
						)
						context.lineTo(startX, opts.height - opts.area[2])
						context.lineTo(startX, item.y)
						context.setLineWidth(1)
						context.setStrokeStyle(strokeColor)
					}
					context.setFillStyle(fillColor)
					context.closePath()
					context.fill()
				}
			}
			columnIndex += 1
		}
		//绘制区域图数据
		if (eachSeries.type == 'area') {
			let splitPointList = splitPoints(points, eachSeries)
			for (let i = 0; i < splitPointList.length; i++) {
				let points = splitPointList[i]
				// 绘制区域数据
				context.beginPath()
				context.setStrokeStyle(eachSeries.color)
				context.setStrokeStyle(
					hexToRgb(eachSeries.color, areaOption.opacity)
				)
				if (areaOption.gradient) {
					let gradient = context.createLinearGradient(
						0,
						opts.area[0],
						0,
						opts.height - opts.area[2]
					)
					gradient.addColorStop(
						'0',
						hexToRgb(eachSeries.color, areaOption.opacity)
					)
					gradient.addColorStop('1.0', hexToRgb('#FFFFFF', 0.1))
					context.setFillStyle(gradient)
				} else {
					context.setFillStyle(
						hexToRgb(eachSeries.color, areaOption.opacity)
					)
				}
				context.setLineWidth(2 * opts.pix)
				if (points.length > 1) {
					var firstPoint = points[0]
					let lastPoint = points[points.length - 1]
					context.moveTo(firstPoint.x, firstPoint.y)
					let startPoint = 0
					if (eachSeries.style === 'curve') {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								var ctrlPoint = createCurveControlPoints(
									points,
									j - 1
								)
								context.bezierCurveTo(
									ctrlPoint.ctrA.x,
									ctrlPoint.ctrA.y,
									ctrlPoint.ctrB.x,
									ctrlPoint.ctrB.y,
									item.x,
									item.y
								)
							}
						}
					} else {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								context.lineTo(item.x, item.y)
							}
						}
					}
					context.lineTo(lastPoint.x, endY)
					context.lineTo(firstPoint.x, endY)
					context.lineTo(firstPoint.x, firstPoint.y)
				} else {
					let item = points[0]
					context.moveTo(item.x - eachSpacing / 2, item.y)
					// context.lineTo(item.x + eachSpacing / 2, item.y);
					// context.lineTo(item.x + eachSpacing / 2, endY);
					// context.lineTo(item.x - eachSpacing / 2, endY);
					// context.moveTo(item.x - eachSpacing / 2, item.y);
				}
				context.closePath()
				context.fill()
			}
		}
		// 绘制折线数据图
		if (eachSeries.type == 'line') {
			var splitPointList = splitPoints(points, eachSeries)
			splitPointList.forEach(function (points, index) {
				if (eachSeries.lineType == 'dash') {
					let dashLength = eachSeries.dashLength
						? eachSeries.dashLength
						: 8
					dashLength *= opts.pix
					context.setLineDash([dashLength, dashLength])
				}
				context.beginPath()
				context.setStrokeStyle(eachSeries.color)
				context.setLineWidth(lineOption.width * opts.pix)
				if (points.length === 1) {
					context.moveTo(points[0].x, points[0].y)
					// context.arc(points[0].x, points[0].y, 1, 0, 2 * Math.PI);
				} else {
					context.moveTo(points[0].x, points[0].y)
					let startPoint = 0
					if (eachSeries.style == 'curve') {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								var ctrlPoint = createCurveControlPoints(
									points,
									j - 1
								)
								context.bezierCurveTo(
									ctrlPoint.ctrA.x,
									ctrlPoint.ctrA.y,
									ctrlPoint.ctrB.x,
									ctrlPoint.ctrB.y,
									item.x,
									item.y
								)
							}
						}
					} else {
						for (let j = 0; j < points.length; j++) {
							let item = points[j]
							if (startPoint == 0 && item.x > leftSpace) {
								context.moveTo(item.x, item.y)
								startPoint = 1
							}
							if (
								j > 0 &&
								item.x > leftSpace &&
								item.x < rightSpace
							) {
								context.lineTo(item.x, item.y)
							}
						}
					}
					context.moveTo(points[0].x, points[0].y)
				}
				context.stroke()
				context.setLineDash([])
			})
		}
		// 绘制点数据图
		if (eachSeries.type == 'point') {
			eachSeries.addPoint = true
		}
		if (eachSeries.addPoint == true && eachSeries.type !== 'column') {
			drawPointShape(
				points,
				eachSeries.color,
				eachSeries.pointShape,
				context,
				opts
			)
		}
	})
	if (opts.dataLabel !== false && process === 1) {
		var columnIndex = 0
		series.forEach(function (eachSeries, seriesIndex) {
			let ranges, minRange, maxRange
			ranges = [].concat(
				opts.chartData.yAxisData.ranges[eachSeries.index]
			)
			minRange = ranges.pop()
			maxRange = ranges.shift()
			var data = eachSeries.data
			var points = getDataPoints(
				data,
				minRange,
				maxRange,
				xAxisPoints,
				eachSpacing,
				opts,
				config,
				process
			)
			if (eachSeries.type !== 'column') {
				drawPointText(points, eachSeries, config, context, opts)
			} else {
				points = fixColumeData(
					points,
					eachSpacing,
					columnLength,
					columnIndex,
					config,
					opts
				)
				drawPointText(points, eachSeries, config, context, opts)
				columnIndex += 1
			}
		})
	}
	context.restore()
	return {
		xAxisPoints: xAxisPoints,
		calPoints: calPoints,
		eachSpacing: eachSpacing,
	}
}

function drawToolTipBridge(
	opts,
	config,
	context,
	process,
	eachSpacing,
	xAxisPoints
) {
	var toolTipOption = opts.extra.tooltip || {}
	if (
		toolTipOption.horizentalLine &&
		opts.tooltip &&
		process === 1 &&
		(opts.type == 'line' ||
			opts.type == 'area' ||
			opts.type == 'column' ||
			opts.type == 'mount' ||
			opts.type == 'candle' ||
			opts.type == 'mix')
	) {
		drawToolTipHorizentalLine(
			opts,
			config,
			context,
			eachSpacing,
			xAxisPoints
		)
	}
	context.save()
	if (
		opts._scrollDistance_ &&
		opts._scrollDistance_ !== 0 &&
		opts.enableScroll === true
	) {
		context.translate(opts._scrollDistance_, 0)
	}
	if (
		opts.tooltip &&
		opts.tooltip.textList &&
		opts.tooltip.textList.length &&
		process === 1
	) {
		drawToolTip(
			opts.tooltip.textList,
			opts.tooltip.offset,
			opts,
			config,
			context,
			eachSpacing,
			xAxisPoints
		)
	}
	context.restore()
}

function drawXAxis(categories, opts, config, context) {
	let xAxisData = opts.chartData.xAxisData,
		xAxisPoints = xAxisData.xAxisPoints,
		startX = xAxisData.startX,
		endX = xAxisData.endX,
		eachSpacing = xAxisData.eachSpacing
	var boundaryGap = 'center'
	if (
		opts.type == 'bar' ||
		opts.type == 'line' ||
		opts.type == 'area' ||
		opts.type == 'scatter' ||
		opts.type == 'bubble'
	) {
		boundaryGap = opts.xAxis.boundaryGap
	}
	var startY = opts.height - opts.area[2]
	var endY = opts.area[0]

	//绘制滚动条
	if (opts.enableScroll && opts.xAxis.scrollShow) {
		var scrollY = opts.height - opts.area[2] + config.xAxisHeight
		var scrollScreenWidth = endX - startX
		var scrollTotalWidth = eachSpacing * (xAxisPoints.length - 1)
		if (
			opts.type == 'mount' &&
			opts.extra &&
			opts.extra.mount &&
			opts.extra.mount.widthRatio &&
			opts.extra.mount.widthRatio > 1
		) {
			if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
			scrollTotalWidth += (opts.extra.mount.widthRatio - 1) * eachSpacing
		}
		var scrollWidth =
			(scrollScreenWidth * scrollScreenWidth) / scrollTotalWidth
		var scrollLeft = 0
		if (opts._scrollDistance_) {
			scrollLeft =
				(-opts._scrollDistance_ * scrollScreenWidth) / scrollTotalWidth
		}
		context.beginPath()
		context.setLineCap('round')
		context.setLineWidth(6 * opts.pix)
		context.setStrokeStyle(opts.xAxis.scrollBackgroundColor || '#EFEBEF')
		context.moveTo(startX, scrollY)
		context.lineTo(endX, scrollY)
		context.stroke()
		context.closePath()
		context.beginPath()
		context.setLineCap('round')
		context.setLineWidth(6 * opts.pix)
		context.setStrokeStyle(opts.xAxis.scrollColor || '#A6A6A6')
		context.moveTo(startX + scrollLeft, scrollY)
		context.lineTo(startX + scrollLeft + scrollWidth, scrollY)
		context.stroke()
		context.closePath()
		context.setLineCap('butt')
	}
	context.save()
	if (opts._scrollDistance_ && opts._scrollDistance_ !== 0) {
		context.translate(opts._scrollDistance_, 0)
	}
	//绘制X轴刻度线
	if (opts.xAxis.calibration === true) {
		context.setStrokeStyle(opts.xAxis.gridColor || '#cccccc')
		context.setLineCap('butt')
		context.setLineWidth(1 * opts.pix)
		xAxisPoints.forEach(function (item, index) {
			if (index > 0) {
				context.beginPath()
				context.moveTo(item - eachSpacing / 2, startY)
				context.lineTo(item - eachSpacing / 2, startY + 3 * opts.pix)
				context.closePath()
				context.stroke()
			}
		})
	}
	//绘制X轴网格
	if (opts.xAxis.disableGrid !== true) {
		context.setStrokeStyle(opts.xAxis.gridColor || '#cccccc')
		context.setLineCap('butt')
		context.setLineWidth(1 * opts.pix)
		if (opts.xAxis.gridType == 'dash') {
			context.setLineDash([
				opts.xAxis.dashLength * opts.pix,
				opts.xAxis.dashLength * opts.pix,
			])
		}
		opts.xAxis.gridEval = opts.xAxis.gridEval || 1
		xAxisPoints.forEach(function (item, index) {
			if (index % opts.xAxis.gridEval == 0) {
				context.beginPath()
				context.moveTo(item, startY)
				context.lineTo(item, endY)
				context.stroke()
			}
		})
		context.setLineDash([])
	}
	//绘制X轴文案
	if (opts.xAxis.disabled !== true) {
		// 对X轴列表做抽稀处理
		//默认全部显示X轴标签
		let maxXAxisListLength = categories.length
		//如果设置了X轴单屏数量
		if (opts.xAxis.labelCount) {
			//如果设置X轴密度
			if (opts.xAxis.itemCount) {
				maxXAxisListLength = Math.ceil(
					(categories.length / opts.xAxis.itemCount) *
						opts.xAxis.labelCount
				)
			} else {
				maxXAxisListLength = opts.xAxis.labelCount
			}
			maxXAxisListLength -= 1
		}

		let ratio = Math.ceil(categories.length / maxXAxisListLength)

		let newCategories = []
		let cgLength = categories.length
		for (let i = 0; i < cgLength; i++) {
			if (i % ratio !== 0) {
				newCategories.push('')
			} else {
				newCategories.push(categories[i])
			}
		}
		newCategories[cgLength - 1] = categories[cgLength - 1]
		var xAxisFontSize = opts.xAxis.fontSize * opts.pix || config.fontSize
		if (config._xAxisTextAngle_ === 0) {
			newCategories.forEach(function (item, index) {
				var xitem = opts.xAxis.formatter
					? opts.xAxis.formatter(item, index, opts)
					: item
				var offset =
					-measureText(String(xitem), xAxisFontSize, context) / 2
				if (boundaryGap == 'center') {
					offset += eachSpacing / 2
				}
				var scrollHeight = 0
				if (opts.xAxis.scrollShow) {
					scrollHeight = 6 * opts.pix
				}
				// 如果在主视图区域内
				var _scrollDistance_ = opts._scrollDistance_ || 0
				var truePoints =
					boundaryGap == 'center'
						? xAxisPoints[index] + eachSpacing / 2
						: xAxisPoints[index]
				if (
					truePoints - Math.abs(_scrollDistance_) >=
						opts.area[3] - 1 &&
					truePoints - Math.abs(_scrollDistance_) <=
						opts.width - opts.area[1] + 1
				) {
					context.beginPath()
					context.setFontSize(xAxisFontSize)
					context.setFillStyle(opts.xAxis.fontColor || opts.fontColor)
					context.fillText(
						String(xitem),
						xAxisPoints[index] + offset,
						startY +
							opts.xAxis.marginTop * opts.pix +
							((opts.xAxis.lineHeight - opts.xAxis.fontSize) *
								opts.pix) /
								2 +
							opts.xAxis.fontSize * opts.pix
					)
					context.closePath()
					context.stroke()
				}
			})
		} else {
			newCategories.forEach(function (item, index) {
				var xitem = opts.xAxis.formatter
					? opts.xAxis.formatter(item)
					: item
				// 如果在主视图区域内
				var _scrollDistance_ = opts._scrollDistance_ || 0
				var truePoints =
					boundaryGap == 'center'
						? xAxisPoints[index] + eachSpacing / 2
						: xAxisPoints[index]
				if (
					truePoints - Math.abs(_scrollDistance_) >=
						opts.area[3] - 1 &&
					truePoints - Math.abs(_scrollDistance_) <=
						opts.width - opts.area[1] + 1
				) {
					context.save()
					context.beginPath()
					context.setFontSize(xAxisFontSize)
					context.setFillStyle(opts.xAxis.fontColor || opts.fontColor)
					var textWidth = measureText(
						String(xitem),
						xAxisFontSize,
						context
					)
					var offsetX = xAxisPoints[index]
					if (boundaryGap == 'center') {
						offsetX = xAxisPoints[index] + eachSpacing / 2
					}
					var scrollHeight = 0
					if (opts.xAxis.scrollShow) {
						scrollHeight = 6 * opts.pix
					}
					var offsetY =
						startY +
						opts.xAxis.marginTop * opts.pix +
						xAxisFontSize -
						xAxisFontSize *
							Math.abs(Math.sin(config._xAxisTextAngle_))
					if (opts.xAxis.rotateAngle < 0) {
						offsetX -= xAxisFontSize / 2
						textWidth = 0
					} else {
						offsetX += xAxisFontSize / 2
						textWidth = -textWidth
					}
					context.translate(offsetX, offsetY)
					context.rotate(-1 * config._xAxisTextAngle_)
					context.fillText(String(xitem), textWidth, 0)
					context.closePath()
					context.stroke()
					context.restore()
				}
			})
		}
	}
	context.restore()

	//画X轴标题
	if (opts.xAxis.title) {
		context.beginPath()
		context.setFontSize(opts.xAxis.titleFontSize * opts.pix)
		context.setFillStyle(opts.xAxis.titleFontColor)
		context.fillText(
			String(opts.xAxis.title),
			opts.width - opts.area[1] + opts.xAxis.titleOffsetX * opts.pix,
			opts.height -
				opts.area[2] +
				opts.xAxis.marginTop * opts.pix +
				((opts.xAxis.lineHeight - opts.xAxis.titleFontSize) *
					opts.pix) /
					2 +
				(opts.xAxis.titleFontSize + opts.xAxis.titleOffsetY) * opts.pix
		)
		context.closePath()
		context.stroke()
	}

	//绘制X轴轴线
	if (opts.xAxis.axisLine) {
		context.beginPath()
		context.setStrokeStyle(opts.xAxis.axisLineColor)
		context.setLineWidth(1 * opts.pix)
		context.moveTo(startX, opts.height - opts.area[2])
		context.lineTo(endX, opts.height - opts.area[2])
		context.stroke()
	}
}

function drawYAxisGrid(categories, opts, config, context) {
	if (opts.yAxis.disableGrid === true) {
		return
	}
	let spacingValid = opts.height - opts.area[0] - opts.area[2]
	let eachSpacing = spacingValid / opts.yAxis.splitNumber
	let startX = opts.area[3]
	let xAxisPoints = opts.chartData.xAxisData.xAxisPoints,
		xAxiseachSpacing = opts.chartData.xAxisData.eachSpacing
	let TotalWidth = xAxiseachSpacing * (xAxisPoints.length - 1)
	if (
		opts.type == 'mount' &&
		opts.extra &&
		opts.extra.mount &&
		opts.extra.mount.widthRatio &&
		opts.extra.mount.widthRatio > 1
	) {
		if (opts.extra.mount.widthRatio > 2) opts.extra.mount.widthRatio = 2
		TotalWidth += (opts.extra.mount.widthRatio - 1) * xAxiseachSpacing
	}
	let endX = startX + TotalWidth
	let points = []
	let startY = 1
	if (opts.xAxis.axisLine === false) {
		startY = 0
	}
	for (let i = startY; i < opts.yAxis.splitNumber + 1; i++) {
		points.push(opts.height - opts.area[2] - eachSpacing * i)
	}
	context.save()
	if (opts._scrollDistance_ && opts._scrollDistance_ !== 0) {
		context.translate(opts._scrollDistance_, 0)
	}
	if (opts.yAxis.gridType == 'dash') {
		context.setLineDash([
			opts.yAxis.dashLength * opts.pix,
			opts.yAxis.dashLength * opts.pix,
		])
	}
	context.setStrokeStyle(opts.yAxis.gridColor)
	context.setLineWidth(1 * opts.pix)
	points.forEach(function (item, index) {
		context.beginPath()
		context.moveTo(startX, item)
		context.lineTo(endX, item)
		context.stroke()
	})
	context.setLineDash([])
	context.restore()
}

function drawYAxis(series, opts, config, context) {
	if (opts.yAxis.disabled === true) {
		return
	}
	var spacingValid = opts.height - opts.area[0] - opts.area[2]
	var eachSpacing = spacingValid / opts.yAxis.splitNumber
	var startX = opts.area[3]
	var endX = opts.width - opts.area[1]
	var endY = opts.height - opts.area[2]
	// set YAxis background
	context.beginPath()
	context.setFillStyle(opts.background)
	if (
		opts.enableScroll == true &&
		opts.xAxis.scrollPosition &&
		opts.xAxis.scrollPosition !== 'left'
	) {
		context.fillRect(0, 0, startX, endY + 2 * opts.pix)
	}
	if (
		opts.enableScroll == true &&
		opts.xAxis.scrollPosition &&
		opts.xAxis.scrollPosition !== 'right'
	) {
		context.fillRect(endX, 0, opts.width, endY + 2 * opts.pix)
	}
	context.closePath()
	context.stroke()

	let tStartLeft = opts.area[3]
	let tStartRight = opts.width - opts.area[1]
	let tStartCenter =
		opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2
	if (opts.yAxis.data) {
		for (let i = 0; i < opts.yAxis.data.length; i++) {
			let yData = opts.yAxis.data[i]
			var points = []
			if (yData.type === 'categories') {
				for (let i = 0; i <= yData.categories.length; i++) {
					points.push(
						opts.area[0] +
							spacingValid / yData.categories.length / 2 +
							(spacingValid / yData.categories.length) * i
					)
				}
			} else {
				for (let i = 0; i <= opts.yAxis.splitNumber; i++) {
					points.push(opts.area[0] + eachSpacing * i)
				}
			}
			if (yData.disabled !== true) {
				let rangesFormat = opts.chartData.yAxisData.rangesFormat[i]
				let yAxisFontSize = yData.fontSize
					? yData.fontSize * opts.pix
					: config.fontSize
				let yAxisWidth = opts.chartData.yAxisData.yAxisWidth[i]
				let textAlign = yData.textAlign || 'right'
				//画Y轴刻度及文案
				rangesFormat.forEach(function (item, index) {
					var pos = points[index]
					context.beginPath()
					context.setFontSize(yAxisFontSize)
					context.setLineWidth(1 * opts.pix)
					context.setStrokeStyle(yData.axisLineColor || '#cccccc')
					context.setFillStyle(yData.fontColor || opts.fontColor)
					let tmpstrat = 0
					let gapwidth = 4 * opts.pix
					if (yAxisWidth.position == 'left') {
						//画刻度线
						if (yData.calibration == true) {
							context.moveTo(tStartLeft, pos)
							context.lineTo(tStartLeft - 3 * opts.pix, pos)
							gapwidth += 3 * opts.pix
						}
						//画文字
						switch (textAlign) {
							case 'left':
								context.setTextAlign('left')
								tmpstrat = tStartLeft - yAxisWidth.width
								break
							case 'right':
								context.setTextAlign('right')
								tmpstrat = tStartLeft - gapwidth
								break
							default:
								context.setTextAlign('center')
								tmpstrat = tStartLeft - yAxisWidth.width / 2
						}
						context.fillText(
							String(item),
							tmpstrat,
							pos + yAxisFontSize / 2 - 3 * opts.pix
						)
					} else if (yAxisWidth.position == 'right') {
						//画刻度线
						if (yData.calibration == true) {
							context.moveTo(tStartRight, pos)
							context.lineTo(tStartRight + 3 * opts.pix, pos)
							gapwidth += 3 * opts.pix
						}
						switch (textAlign) {
							case 'left':
								context.setTextAlign('left')
								tmpstrat = tStartRight + gapwidth
								break
							case 'right':
								context.setTextAlign('right')
								tmpstrat = tStartRight + yAxisWidth.width
								break
							default:
								context.setTextAlign('center')
								tmpstrat = tStartRight + yAxisWidth.width / 2
						}
						context.fillText(
							String(item),
							tmpstrat,
							pos + yAxisFontSize / 2 - 3 * opts.pix
						)
					} else if (yAxisWidth.position == 'center') {
						//画刻度线
						if (yData.calibration == true) {
							context.moveTo(tStartCenter, pos)
							context.lineTo(tStartCenter - 3 * opts.pix, pos)
							gapwidth += 3 * opts.pix
						}
						//画文字
						switch (textAlign) {
							case 'left':
								context.setTextAlign('left')
								tmpstrat = tStartCenter - yAxisWidth.width
								break
							case 'right':
								context.setTextAlign('right')
								tmpstrat = tStartCenter - gapwidth
								break
							default:
								context.setTextAlign('center')
								tmpstrat = tStartCenter - yAxisWidth.width / 2
						}
						context.fillText(
							String(item),
							tmpstrat,
							pos + yAxisFontSize / 2 - 3 * opts.pix
						)
					}
					context.closePath()
					context.stroke()
					context.setTextAlign('left')
				})
				//画Y轴轴线
				if (yData.axisLine !== false) {
					context.beginPath()
					context.setStrokeStyle(yData.axisLineColor || '#cccccc')
					context.setLineWidth(1 * opts.pix)
					if (yAxisWidth.position == 'left') {
						context.moveTo(tStartLeft, opts.height - opts.area[2])
						context.lineTo(tStartLeft, opts.area[0])
					} else if (yAxisWidth.position == 'right') {
						context.moveTo(tStartRight, opts.height - opts.area[2])
						context.lineTo(tStartRight, opts.area[0])
					} else if (yAxisWidth.position == 'center') {
						context.moveTo(tStartCenter, opts.height - opts.area[2])
						context.lineTo(tStartCenter, opts.area[0])
					}
					context.stroke()
				}
				//画Y轴标题
				if (opts.yAxis.showTitle) {
					let titleFontSize =
						yData.titleFontSize * opts.pix || config.fontSize
					let title = yData.title
					context.beginPath()
					context.setFontSize(titleFontSize)
					context.setFillStyle(yData.titleFontColor || opts.fontColor)
					if (yAxisWidth.position == 'left') {
						context.fillText(
							title,
							tStartLeft -
								measureText(title, titleFontSize, context) / 2 +
								(yData.titleOffsetX || 0),
							opts.area[0] -
								(10 - (yData.titleOffsetY || 0)) * opts.pix
						)
					} else if (yAxisWidth.position == 'right') {
						context.fillText(
							title,
							tStartRight -
								measureText(title, titleFontSize, context) / 2 +
								(yData.titleOffsetX || 0),
							opts.area[0] -
								(10 - (yData.titleOffsetY || 0)) * opts.pix
						)
					} else if (yAxisWidth.position == 'center') {
						context.fillText(
							title,
							tStartCenter -
								measureText(title, titleFontSize, context) / 2 +
								(yData.titleOffsetX || 0),
							opts.area[0] -
								(10 - (yData.titleOffsetY || 0)) * opts.pix
						)
					}
					context.closePath()
					context.stroke()
				}
				if (yAxisWidth.position == 'left') {
					tStartLeft -=
						yAxisWidth.width + opts.yAxis.padding * opts.pix
				} else {
					tStartRight +=
						yAxisWidth.width + opts.yAxis.padding * opts.pix
				}
			}
		}
	}
}

function drawLegend(series, opts, config, context, chartData) {
	if (opts.legend.show === false) {
		return
	}
	let legendData = chartData.legendData
	let legendList = legendData.points
	let legendArea = legendData.area
	let padding = opts.legend.padding * opts.pix
	let fontSize = opts.legend.fontSize * opts.pix
	let shapeWidth = 15 * opts.pix
	let shapeRight = 5 * opts.pix
	let itemGap = opts.legend.itemGap * opts.pix
	let lineHeight = Math.max(opts.legend.lineHeight * opts.pix, fontSize)
	//画背景及边框
	context.beginPath()
	context.setLineWidth(opts.legend.borderWidth * opts.pix)
	context.setStrokeStyle(opts.legend.borderColor)
	context.setFillStyle(opts.legend.backgroundColor)
	context.moveTo(legendArea.start.x, legendArea.start.y)
	context.rect(
		legendArea.start.x,
		legendArea.start.y,
		legendArea.width,
		legendArea.height
	)
	context.closePath()
	context.fill()
	context.stroke()
	legendList.forEach(function (itemList, listIndex) {
		let width = 0
		let height = 0
		width = legendData.widthArr[listIndex]
		height = legendData.heightArr[listIndex]
		let startX = 0
		let startY = 0
		if (opts.legend.position == 'top' || opts.legend.position == 'bottom') {
			switch (opts.legend.float) {
				case 'left':
					startX = legendArea.start.x + padding
					break
				case 'right':
					startX = legendArea.start.x + legendArea.width - width
					break
				default:
					startX = legendArea.start.x + (legendArea.width - width) / 2
			}
			startY = legendArea.start.y + padding + listIndex * lineHeight
		} else {
			if (listIndex == 0) {
				width = 0
			} else {
				width = legendData.widthArr[listIndex - 1]
			}
			startX = legendArea.start.x + padding + width
			startY =
				legendArea.start.y + padding + (legendArea.height - height) / 2
		}
		context.setFontSize(config.fontSize)
		for (let i = 0; i < itemList.length; i++) {
			let item = itemList[i]
			item.area = [0, 0, 0, 0]
			item.area[0] = startX
			item.area[1] = startY
			item.area[3] = startY + lineHeight
			context.beginPath()
			context.setLineWidth(1 * opts.pix)
			context.setStrokeStyle(
				item.show ? item.color : opts.legend.hiddenColor
			)
			context.setFillStyle(
				item.show ? item.color : opts.legend.hiddenColor
			)
			switch (item.legendShape) {
				case 'line':
					context.moveTo(
						startX,
						startY + 0.5 * lineHeight - 2 * opts.pix
					)
					context.fillRect(
						startX,
						startY + 0.5 * lineHeight - 2 * opts.pix,
						15 * opts.pix,
						4 * opts.pix
					)
					break
				case 'triangle':
					context.moveTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					context.lineTo(
						startX + 2.5 * opts.pix,
						startY + 0.5 * lineHeight + 5 * opts.pix
					)
					context.lineTo(
						startX + 12.5 * opts.pix,
						startY + 0.5 * lineHeight + 5 * opts.pix
					)
					context.lineTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					break
				case 'diamond':
					context.moveTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					context.lineTo(
						startX + 2.5 * opts.pix,
						startY + 0.5 * lineHeight
					)
					context.lineTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight + 5 * opts.pix
					)
					context.lineTo(
						startX + 12.5 * opts.pix,
						startY + 0.5 * lineHeight
					)
					context.lineTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					break
				case 'circle':
					context.moveTo(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight
					)
					context.arc(
						startX + 7.5 * opts.pix,
						startY + 0.5 * lineHeight,
						5 * opts.pix,
						0,
						2 * Math.PI
					)
					break
				case 'rect':
					context.moveTo(
						startX,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					context.fillRect(
						startX,
						startY + 0.5 * lineHeight - 5 * opts.pix,
						15 * opts.pix,
						10 * opts.pix
					)
					break
				case 'square':
					context.moveTo(
						startX + 5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					context.fillRect(
						startX + 5 * opts.pix,
						startY + 0.5 * lineHeight - 5 * opts.pix,
						10 * opts.pix,
						10 * opts.pix
					)
					break
				case 'none':
					break
				default:
					context.moveTo(
						startX,
						startY + 0.5 * lineHeight - 5 * opts.pix
					)
					context.fillRect(
						startX,
						startY + 0.5 * lineHeight - 5 * opts.pix,
						15 * opts.pix,
						10 * opts.pix
					)
			}
			context.closePath()
			context.fill()
			context.stroke()
			startX += shapeWidth + shapeRight
			let fontTrans = 0.5 * lineHeight + 0.5 * fontSize - 2
			const legendText = item.legendText ? item.legendText : item.name
			context.beginPath()
			context.setFontSize(fontSize)
			context.setFillStyle(
				item.show ? opts.legend.fontColor : opts.legend.hiddenColor
			)
			context.fillText(legendText, startX, startY + fontTrans)
			context.closePath()
			context.stroke()
			if (
				opts.legend.position == 'top' ||
				opts.legend.position == 'bottom'
			) {
				startX += measureText(legendText, fontSize, context) + itemGap
				item.area[2] = startX
			} else {
				item.area[2] =
					startX +
					measureText(legendText, fontSize, context) +
					itemGap
				startX -= shapeWidth + shapeRight
				startY += lineHeight
			}
		}
	})
}

function drawPieDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var pieOption = assign(
		{},
		{
			activeOpacity: 0.5,
			activeRadius: 10,
			offsetAngle: 0,
			labelWidth: 15,
			ringWidth: 30,
			customRadius: 0,
			border: false,
			borderWidth: 2,
			borderColor: '#FFFFFF',
			centerColor: '#FFFFFF',
			linearType: 'none',
			customColor: [],
		},
		opts.type == 'pie' ? opts.extra.pie : opts.extra.ring
	)
	var centerPosition = {
		x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
		y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2,
	}
	if (config.pieChartLinePadding == 0) {
		config.pieChartLinePadding = pieOption.activeRadius * opts.pix
	}

	var radius = Math.min(
		(opts.width - opts.area[1] - opts.area[3]) / 2 -
			config.pieChartLinePadding -
			config.pieChartTextPadding -
			config._pieTextMaxLength_,
		(opts.height - opts.area[0] - opts.area[2]) / 2 -
			config.pieChartLinePadding -
			config.pieChartTextPadding
	)
	radius = radius < 10 ? 10 : radius
	if (pieOption.customRadius > 0) {
		radius = pieOption.customRadius * opts.pix
	}
	series = getPieDataPoints(series, radius, process)
	var activeRadius = pieOption.activeRadius * opts.pix
	pieOption.customColor = fillCustomColor(
		pieOption.linearType,
		pieOption.customColor,
		series,
		config
	)
	series = series.map(function (eachSeries) {
		eachSeries._start_ += (pieOption.offsetAngle * Math.PI) / 180
		return eachSeries
	})
	series.forEach(function (eachSeries, seriesIndex) {
		if (opts.tooltip) {
			if (opts.tooltip.index == seriesIndex) {
				context.beginPath()
				context.setFillStyle(
					hexToRgb(eachSeries.color, pieOption.activeOpacity || 0.5)
				)
				context.moveTo(centerPosition.x, centerPosition.y)
				context.arc(
					centerPosition.x,
					centerPosition.y,
					eachSeries._radius_ + activeRadius,
					eachSeries._start_,
					eachSeries._start_ + 2 * eachSeries._proportion_ * Math.PI
				)
				context.closePath()
				context.fill()
			}
		}
		context.beginPath()
		context.setLineWidth(pieOption.borderWidth * opts.pix)
		context.lineJoin = 'round'
		context.setStrokeStyle(pieOption.borderColor)
		var fillcolor = eachSeries.color
		if (pieOption.linearType == 'custom') {
			var grd
			if (context.createCircularGradient) {
				grd = context.createCircularGradient(
					centerPosition.x,
					centerPosition.y,
					eachSeries._radius_
				)
			} else {
				grd = context.createRadialGradient(
					centerPosition.x,
					centerPosition.y,
					0,
					centerPosition.x,
					centerPosition.y,
					eachSeries._radius_
				)
			}
			grd.addColorStop(
				0,
				hexToRgb(pieOption.customColor[eachSeries.linearIndex], 1)
			)
			grd.addColorStop(1, hexToRgb(eachSeries.color, 1))
			fillcolor = grd
		}
		context.setFillStyle(fillcolor)
		context.moveTo(centerPosition.x, centerPosition.y)
		context.arc(
			centerPosition.x,
			centerPosition.y,
			eachSeries._radius_,
			eachSeries._start_,
			eachSeries._start_ + 2 * eachSeries._proportion_ * Math.PI
		)
		context.closePath()
		context.fill()
		if (pieOption.border == true) {
			context.stroke()
		}
	})
	if (opts.type === 'ring') {
		var innerPieWidth = radius * 0.6
		if (
			typeof pieOption.ringWidth === 'number' &&
			pieOption.ringWidth > 0
		) {
			innerPieWidth = Math.max(0, radius - pieOption.ringWidth * opts.pix)
		}
		context.beginPath()
		context.setFillStyle(pieOption.centerColor)
		context.moveTo(centerPosition.x, centerPosition.y)
		context.arc(
			centerPosition.x,
			centerPosition.y,
			innerPieWidth,
			0,
			2 * Math.PI
		)
		context.closePath()
		context.fill()
	}
	if (opts.dataLabel !== false && process === 1) {
		drawPieText(series, opts, config, context, radius, centerPosition)
	}
	if (process === 1 && opts.type === 'ring') {
		drawRingTitle(opts, config, context, centerPosition)
	}
	return {
		center: centerPosition,
		radius: radius,
		series: series,
	}
}

function drawRoseDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var roseOption = assign(
		{},
		{
			type: 'area',
			activeOpacity: 0.5,
			activeRadius: 10,
			offsetAngle: 0,
			labelWidth: 15,
			border: false,
			borderWidth: 2,
			borderColor: '#FFFFFF',
			linearType: 'none',
			customColor: [],
		},
		opts.extra.rose
	)
	if (config.pieChartLinePadding == 0) {
		config.pieChartLinePadding = roseOption.activeRadius * opts.pix
	}
	var centerPosition = {
		x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
		y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2,
	}
	var radius = Math.min(
		(opts.width - opts.area[1] - opts.area[3]) / 2 -
			config.pieChartLinePadding -
			config.pieChartTextPadding -
			config._pieTextMaxLength_,
		(opts.height - opts.area[0] - opts.area[2]) / 2 -
			config.pieChartLinePadding -
			config.pieChartTextPadding
	)
	radius = radius < 10 ? 10 : radius
	var minRadius = roseOption.minRadius || radius * 0.5
	if (radius < minRadius) {
		radius = minRadius + 10
	}
	series = getRoseDataPoints(
		series,
		roseOption.type,
		minRadius,
		radius,
		process
	)
	var activeRadius = roseOption.activeRadius * opts.pix
	roseOption.customColor = fillCustomColor(
		roseOption.linearType,
		roseOption.customColor,
		series,
		config
	)
	series = series.map(function (eachSeries) {
		eachSeries._start_ += ((roseOption.offsetAngle || 0) * Math.PI) / 180
		return eachSeries
	})
	series.forEach(function (eachSeries, seriesIndex) {
		if (opts.tooltip) {
			if (opts.tooltip.index == seriesIndex) {
				context.beginPath()
				context.setFillStyle(
					hexToRgb(eachSeries.color, roseOption.activeOpacity || 0.5)
				)
				context.moveTo(centerPosition.x, centerPosition.y)
				context.arc(
					centerPosition.x,
					centerPosition.y,
					activeRadius + eachSeries._radius_,
					eachSeries._start_,
					eachSeries._start_ +
						2 * eachSeries._rose_proportion_ * Math.PI
				)
				context.closePath()
				context.fill()
			}
		}
		context.beginPath()
		context.setLineWidth(roseOption.borderWidth * opts.pix)
		context.lineJoin = 'round'
		context.setStrokeStyle(roseOption.borderColor)
		var fillcolor = eachSeries.color
		if (roseOption.linearType == 'custom') {
			var grd
			if (context.createCircularGradient) {
				grd = context.createCircularGradient(
					centerPosition.x,
					centerPosition.y,
					eachSeries._radius_
				)
			} else {
				grd = context.createRadialGradient(
					centerPosition.x,
					centerPosition.y,
					0,
					centerPosition.x,
					centerPosition.y,
					eachSeries._radius_
				)
			}
			grd.addColorStop(
				0,
				hexToRgb(roseOption.customColor[eachSeries.linearIndex], 1)
			)
			grd.addColorStop(1, hexToRgb(eachSeries.color, 1))
			fillcolor = grd
		}
		context.setFillStyle(fillcolor)
		context.moveTo(centerPosition.x, centerPosition.y)
		context.arc(
			centerPosition.x,
			centerPosition.y,
			eachSeries._radius_,
			eachSeries._start_,
			eachSeries._start_ + 2 * eachSeries._rose_proportion_ * Math.PI
		)
		context.closePath()
		context.fill()
		if (roseOption.border == true) {
			context.stroke()
		}
	})

	if (opts.dataLabel !== false && process === 1) {
		drawPieText(series, opts, config, context, radius, centerPosition)
	}
	return {
		center: centerPosition,
		radius: radius,
		series: series,
	}
}

function drawArcbarDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var arcbarOption = assign(
		{},
		{
			startAngle: 0.75,
			endAngle: 0.25,
			type: 'default',
			direction: 'cw',
			lineCap: 'round',
			width: 12,
			gap: 2,
			linearType: 'none',
			customColor: [],
		},
		opts.extra.arcbar
	)
	series = getArcbarDataPoints(series, arcbarOption, process)
	var centerPosition
	if (arcbarOption.centerX || arcbarOption.centerY) {
		centerPosition = {
			x: arcbarOption.centerX ? arcbarOption.centerX : opts.width / 2,
			y: arcbarOption.centerY ? arcbarOption.centerY : opts.height / 2,
		}
	} else {
		centerPosition = {
			x: opts.width / 2,
			y: opts.height / 2,
		}
	}
	var radius
	if (arcbarOption.radius) {
		radius = arcbarOption.radius
	} else {
		radius = Math.min(centerPosition.x, centerPosition.y)
		radius -= 5 * opts.pix
		radius -= arcbarOption.width / 2
	}
	radius = radius < 10 ? 10 : radius
	arcbarOption.customColor = fillCustomColor(
		arcbarOption.linearType,
		arcbarOption.customColor,
		series,
		config
	)

	for (let i = 0; i < series.length; i++) {
		let eachSeries = series[i]
		//背景颜色
		context.setLineWidth(arcbarOption.width * opts.pix)
		context.setStrokeStyle(arcbarOption.backgroundColor || '#E9E9E9')
		context.setLineCap(arcbarOption.lineCap)
		context.beginPath()
		if (arcbarOption.type == 'default') {
			context.arc(
				centerPosition.x,
				centerPosition.y,
				radius -
					(arcbarOption.width * opts.pix +
						arcbarOption.gap * opts.pix) *
						i,
				arcbarOption.startAngle * Math.PI,
				arcbarOption.endAngle * Math.PI,
				arcbarOption.direction == 'ccw'
			)
		} else {
			context.arc(
				centerPosition.x,
				centerPosition.y,
				radius -
					(arcbarOption.width * opts.pix +
						arcbarOption.gap * opts.pix) *
						i,
				0,
				2 * Math.PI,
				arcbarOption.direction == 'ccw'
			)
		}
		context.stroke()
		//进度条
		var fillColor = eachSeries.color
		if (arcbarOption.linearType == 'custom') {
			var grd = context.createLinearGradient(
				centerPosition.x - radius,
				centerPosition.y,
				centerPosition.x + radius,
				centerPosition.y
			)
			grd.addColorStop(
				1,
				hexToRgb(arcbarOption.customColor[eachSeries.linearIndex], 1)
			)
			grd.addColorStop(0, hexToRgb(eachSeries.color, 1))
			fillColor = grd
		}
		context.setLineWidth(arcbarOption.width * opts.pix)
		context.setStrokeStyle(fillColor)
		context.setLineCap(arcbarOption.lineCap)
		context.beginPath()
		context.arc(
			centerPosition.x,
			centerPosition.y,
			radius -
				(arcbarOption.width * opts.pix + arcbarOption.gap * opts.pix) *
					i,
			arcbarOption.startAngle * Math.PI,
			eachSeries._proportion_ * Math.PI,
			arcbarOption.direction == 'ccw'
		)
		context.stroke()
	}
	drawRingTitle(opts, config, context, centerPosition)
	return {
		center: centerPosition,
		radius: radius,
		series: series,
	}
}

function drawGaugeDataPoints(categories, series, opts, config, context) {
	var process =
		arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1
	var gaugeOption = assign(
		{},
		{
			type: 'default',
			startAngle: 0.75,
			endAngle: 0.25,
			width: 15,
			labelOffset: 13,
			splitLine: {
				fixRadius: 0,
				splitNumber: 10,
				width: 15,
				color: '#FFFFFF',
				childNumber: 5,
				childWidth: 5,
			},
			pointer: {
				width: 15,
				color: 'auto',
			},
		},
		opts.extra.gauge
	)
	if (gaugeOption.oldAngle == undefined) {
		gaugeOption.oldAngle = gaugeOption.startAngle
	}
	if (gaugeOption.oldData == undefined) {
		gaugeOption.oldData = 0
	}
	categories = getGaugeAxisPoints(
		categories,
		gaugeOption.startAngle,
		gaugeOption.endAngle
	)
	var centerPosition = {
		x: opts.width / 2,
		y: opts.height / 2,
	}
	var radius = Math.min(centerPosition.x, centerPosition.y)
	radius -= 5 * opts.pix
	radius -= gaugeOption.width / 2
	radius = radius < 10 ? 10 : radius
	var innerRadius = radius - gaugeOption.width
	var totalAngle = 0
	//判断仪表盘的样式：default百度样式，progress新样式
	if (gaugeOption.type == 'progress') {
		//## 第一步画中心圆形背景和进度条背景
		//中心圆形背景
		var pieRadius = radius - gaugeOption.width * 3
		context.beginPath()
		let gradient = context.createLinearGradient(
			centerPosition.x,
			centerPosition.y - pieRadius,
			centerPosition.x,
			centerPosition.y + pieRadius
		)
		//配置渐变填充（起点：中心点向上减半径；结束点中心点向下加半径）
		gradient.addColorStop('0', hexToRgb(series[0].color, 0.3))
		gradient.addColorStop('1.0', hexToRgb('#FFFFFF', 0.1))
		context.setFillStyle(gradient)
		context.arc(
			centerPosition.x,
			centerPosition.y,
			pieRadius,
			0,
			2 * Math.PI,
			false
		)
		context.fill()
		//画进度条背景
		context.setLineWidth(gaugeOption.width)
		context.setStrokeStyle(hexToRgb(series[0].color, 0.3))
		context.setLineCap('round')
		context.beginPath()
		context.arc(
			centerPosition.x,
			centerPosition.y,
			innerRadius,
			gaugeOption.startAngle * Math.PI,
			gaugeOption.endAngle * Math.PI,
			false
		)
		context.stroke()
		//## 第二步画刻度线
		if (gaugeOption.endAngle < gaugeOption.startAngle) {
			totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
		} else {
			totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
		}
		let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
		let childAngle =
			totalAngle /
			gaugeOption.splitLine.splitNumber /
			gaugeOption.splitLine.childNumber
		let startX =
			-radius - gaugeOption.width * 0.5 - gaugeOption.splitLine.fixRadius
		let endX =
			-radius -
			gaugeOption.width -
			gaugeOption.splitLine.fixRadius +
			gaugeOption.splitLine.width
		context.save()
		context.translate(centerPosition.x, centerPosition.y)
		context.rotate((gaugeOption.startAngle - 1) * Math.PI)
		let len =
			gaugeOption.splitLine.splitNumber *
				gaugeOption.splitLine.childNumber +
			1
		let proc = series[0].data * process
		for (let i = 0; i < len; i++) {
			context.beginPath()
			//刻度线随进度变色
			if (proc > i / len) {
				context.setStrokeStyle(hexToRgb(series[0].color, 1))
			} else {
				context.setStrokeStyle(hexToRgb(series[0].color, 0.3))
			}
			context.setLineWidth(3 * opts.pix)
			context.moveTo(startX, 0)
			context.lineTo(endX, 0)
			context.stroke()
			context.rotate(childAngle * Math.PI)
		}
		context.restore()
		//## 第三步画进度条
		series = getGaugeArcbarDataPoints(series, gaugeOption, process)
		context.setLineWidth(gaugeOption.width)
		context.setStrokeStyle(series[0].color)
		context.setLineCap('round')
		context.beginPath()
		context.arc(
			centerPosition.x,
			centerPosition.y,
			innerRadius,
			gaugeOption.startAngle * Math.PI,
			series[0]._proportion_ * Math.PI,
			false
		)
		context.stroke()
		//## 第四步画指针
		let pointerRadius = radius - gaugeOption.width * 2.5
		context.save()
		context.translate(centerPosition.x, centerPosition.y)
		context.rotate((series[0]._proportion_ - 1) * Math.PI)
		context.beginPath()
		context.setLineWidth(gaugeOption.width / 3)
		let gradient3 = context.createLinearGradient(
			0,
			-pointerRadius * 0.6,
			0,
			pointerRadius * 0.6
		)
		gradient3.addColorStop('0', hexToRgb('#FFFFFF', 0))
		gradient3.addColorStop('0.5', hexToRgb(series[0].color, 1))
		gradient3.addColorStop('1.0', hexToRgb('#FFFFFF', 0))
		context.setStrokeStyle(gradient3)
		context.arc(0, 0, pointerRadius, 0.85 * Math.PI, 1.15 * Math.PI, false)
		context.stroke()
		context.beginPath()
		context.setLineWidth(1)
		context.setStrokeStyle(series[0].color)
		context.setFillStyle(series[0].color)
		context.moveTo(-pointerRadius - gaugeOption.width / 3 / 2, -4)
		context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2 - 4, 0)
		context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2, 4)
		context.lineTo(-pointerRadius - gaugeOption.width / 3 / 2, -4)
		context.stroke()
		context.fill()
		context.restore()
		//default百度样式
	} else {
		//画背景
		context.setLineWidth(gaugeOption.width)
		context.setLineCap('butt')
		for (let i = 0; i < categories.length; i++) {
			let eachCategories = categories[i]
			context.beginPath()
			context.setStrokeStyle(eachCategories.color)
			context.arc(
				centerPosition.x,
				centerPosition.y,
				radius,
				eachCategories._startAngle_ * Math.PI,
				eachCategories._endAngle_ * Math.PI,
				false
			)
			context.stroke()
		}
		context.save()
		//画刻度线
		if (gaugeOption.endAngle < gaugeOption.startAngle) {
			totalAngle = 2 + gaugeOption.endAngle - gaugeOption.startAngle
		} else {
			totalAngle = gaugeOption.startAngle - gaugeOption.endAngle
		}
		let splitAngle = totalAngle / gaugeOption.splitLine.splitNumber
		let childAngle =
			totalAngle /
			gaugeOption.splitLine.splitNumber /
			gaugeOption.splitLine.childNumber
		let startX =
			-radius - gaugeOption.width * 0.5 - gaugeOption.splitLine.fixRadius
		let endX =
			-radius -
			gaugeOption.width * 0.5 -
			gaugeOption.splitLine.fixRadius +
			gaugeOption.splitLine.width
		let childendX =
			-radius -
			gaugeOption.width * 0.5 -
			gaugeOption.splitLine.fixRadius +
			gaugeOption.splitLine.childWidth
		context.translate(centerPosition.x, centerPosition.y)
		context.rotate((gaugeOption.startAngle - 1) * Math.PI)
		for (let i = 0; i < gaugeOption.splitLine.splitNumber + 1; i++) {
			context.beginPath()
			context.setStrokeStyle(gaugeOption.splitLine.color)
			context.setLineWidth(2 * opts.pix)
			context.moveTo(startX, 0)
			context.lineTo(endX, 0)
			context.stroke()
			context.rotate(splitAngle * Math.PI)
		}
		context.restore()
		context.save()
		context.translate(centerPosition.x, centerPosition.y)
		context.rotate((gaugeOption.startAngle - 1) * Math.PI)
		for (
			let i = 0;
			i <
			gaugeOption.splitLine.splitNumber *
				gaugeOption.splitLine.childNumber +
				1;
			i++
		) {
			context.beginPath()
			context.setStrokeStyle(gaugeOption.splitLine.color)
			context.setLineWidth(1 * opts.pix)
			context.moveTo(startX, 0)
			context.lineTo(childendX, 0)
			context.stroke()
			context.rotate(childAngle * Math.PI)
		}
		context.restore()
		//画指针
		series = getGaugeDataPoints(series, categories, gaugeOption, process)
		for (let i = 0; i < series.length; i++) {
			let eachSeries = series[i]
			context.save()
			context.translate(centerPosition.x, centerPosition.y)
			context.rotate((eachSeries._proportion_ - 1) * Math.PI)
			context.beginPath()
			context.setFillStyle(eachSeries.color)
			context.moveTo(gaugeOption.pointer.width, 0)
			context.lineTo(0, -gaugeOption.pointer.width / 2)
			context.lineTo(-innerRadius, 0)
			context.lineTo(0, gaugeOption.pointer.width / 2)
			context.lineTo(gaugeOption.pointer.width, 0)
			context.closePath()
			context.fill()
			context.beginPath()
			context.setFillStyle('#FFFFFF')
			context.arc(
				0,
				0,
				gaugeOption.pointer.width / 6,
				0,
				2 * Math.PI,
				false
			)
			context.fill()
			context.restore()
		}
		if (opts.dataLabel !== false) {
			drawGaugeLabel(
				gaugeOption,
				radius,
				centerPosition,
				opts,
				config,
				context
			)
		}
	}
	//画仪表盘标题，副标题
	drawRingTitle(opts, config, context, centerPosition)
	if (process === 1 && opts.type === 'gauge') {
		opts.extra.gauge.oldAngle = series[0]._proportion_
		opts.extra.gauge.oldData = series[0].data
	}
	return {
		center: centerPosition,
		radius: radius,
		innerRadius: innerRadius,
		categories: categories,
		totalAngle: totalAngle,
	}
}

function drawRadarDataPoints(series, opts, config, context) {
	var process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	var radarOption = assign(
		{},
		{
			gridColor: '#cccccc',
			gridType: 'radar',
			gridEval: 1,
			axisLabel: false,
			axisLabelTofix: 0,
			labelShow: true,
			labelColor: '#666666',
			labelPointShow: false,
			labelPointRadius: 3,
			labelPointColor: '#cccccc',
			opacity: 0.2,
			gridCount: 3,
			border: false,
			borderWidth: 2,
			linearType: 'none',
			customColor: [],
		},
		opts.extra.radar
	)
	var coordinateAngle = getRadarCoordinateSeries(opts.categories.length)
	var centerPosition = {
		x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
		y: opts.area[0] + (opts.height - opts.area[0] - opts.area[2]) / 2,
	}
	var xr = (opts.width - opts.area[1] - opts.area[3]) / 2
	var yr = (opts.height - opts.area[0] - opts.area[2]) / 2
	var radius = Math.min(
		xr -
			(getMaxTextListLength(opts.categories, config.fontSize, context) +
				config.radarLabelTextMargin),
		yr - config.radarLabelTextMargin
	)
	radius -= config.radarLabelTextMargin * opts.pix
	radius = radius < 10 ? 10 : radius
	radius = radarOption.radius ? radarOption.radius : radius
	// 画分割线
	context.beginPath()
	context.setLineWidth(1 * opts.pix)
	context.setStrokeStyle(radarOption.gridColor)
	coordinateAngle.forEach(function (angle, index) {
		var pos = convertCoordinateOrigin(
			radius * Math.cos(angle),
			radius * Math.sin(angle),
			centerPosition
		)
		context.moveTo(centerPosition.x, centerPosition.y)
		if (index % radarOption.gridEval == 0) {
			context.lineTo(pos.x, pos.y)
		}
	})
	context.stroke()
	context.closePath()

	// 画背景网格
	var _loop = function _loop(i) {
		var startPos = {}
		context.beginPath()
		context.setLineWidth(1 * opts.pix)
		context.setStrokeStyle(radarOption.gridColor)
		if (radarOption.gridType == 'radar') {
			coordinateAngle.forEach(function (angle, index) {
				var pos = convertCoordinateOrigin(
					(radius / radarOption.gridCount) * i * Math.cos(angle),
					(radius / radarOption.gridCount) * i * Math.sin(angle),
					centerPosition
				)
				if (index === 0) {
					startPos = pos
					context.moveTo(pos.x, pos.y)
				} else {
					context.lineTo(pos.x, pos.y)
				}
			})
			context.lineTo(startPos.x, startPos.y)
		} else {
			var pos = convertCoordinateOrigin(
				(radius / radarOption.gridCount) * i * Math.cos(1.5),
				(radius / radarOption.gridCount) * i * Math.sin(1.5),
				centerPosition
			)
			context.arc(
				centerPosition.x,
				centerPosition.y,
				centerPosition.y - pos.y,
				0,
				2 * Math.PI,
				false
			)
		}
		context.stroke()
		context.closePath()
	}
	for (var i = 1; i <= radarOption.gridCount; i++) {
		_loop(i)
	}
	radarOption.customColor = fillCustomColor(
		radarOption.linearType,
		radarOption.customColor,
		series,
		config
	)
	var radarDataPoints = getRadarDataPoints(
		coordinateAngle,
		centerPosition,
		radius,
		series,
		opts,
		process
	)
	radarDataPoints.forEach(function (eachSeries, seriesIndex) {
		// 绘制区域数据
		context.beginPath()
		context.setLineWidth(radarOption.borderWidth * opts.pix)
		context.setStrokeStyle(eachSeries.color)

		var fillcolor = hexToRgb(eachSeries.color, radarOption.opacity)
		if (radarOption.linearType == 'custom') {
			var grd
			if (context.createCircularGradient) {
				grd = context.createCircularGradient(
					centerPosition.x,
					centerPosition.y,
					radius
				)
			} else {
				grd = context.createRadialGradient(
					centerPosition.x,
					centerPosition.y,
					0,
					centerPosition.x,
					centerPosition.y,
					radius
				)
			}
			grd.addColorStop(
				0,
				hexToRgb(
					radarOption.customColor[series[seriesIndex].linearIndex],
					radarOption.opacity
				)
			)
			grd.addColorStop(1, hexToRgb(eachSeries.color, radarOption.opacity))
			fillcolor = grd
		}

		context.setFillStyle(fillcolor)
		eachSeries.data.forEach(function (item, index) {
			if (index === 0) {
				context.moveTo(item.position.x, item.position.y)
			} else {
				context.lineTo(item.position.x, item.position.y)
			}
		})
		context.closePath()
		context.fill()
		if (radarOption.border === true) {
			context.stroke()
		}
		context.closePath()
		if (opts.dataPointShape !== false) {
			var points = eachSeries.data.map(function (item) {
				return item.position
			})
			drawPointShape(
				points,
				eachSeries.color,
				eachSeries.pointShape,
				context,
				opts
			)
		}
	})
	// 画刻度值
	if (radarOption.axisLabel === true) {
		const maxData = Math.max(
			radarOption.max,
			Math.max.apply(null, dataCombine(series))
		)
		const stepLength = radius / radarOption.gridCount
		const fontSize = opts.fontSize * opts.pix
		context.setFontSize(fontSize)
		context.setFillStyle(opts.fontColor)
		context.setTextAlign('left')
		for (var i = 0; i < radarOption.gridCount + 1; i++) {
			let label = (i * maxData) / radarOption.gridCount
			label = label.toFixed(radarOption.axisLabelTofix)
			context.fillText(
				String(label),
				centerPosition.x + 3 * opts.pix,
				centerPosition.y - i * stepLength + fontSize / 2
			)
		}
	}

	// draw label text
	drawRadarLabel(
		coordinateAngle,
		radius,
		centerPosition,
		opts,
		config,
		context
	)

	// draw dataLabel
	if (opts.dataLabel !== false && process === 1) {
		radarDataPoints.forEach(function (eachSeries, seriesIndex) {
			context.beginPath()
			var fontSize = eachSeries.textSize * opts.pix || config.fontSize
			context.setFontSize(fontSize)
			context.setFillStyle(eachSeries.textColor || opts.fontColor)
			eachSeries.data.forEach(function (item, index) {
				//如果是中心点垂直的上下点位
				if (Math.abs(item.position.x - centerPosition.x) < 2) {
					//如果在上面
					if (item.position.y < centerPosition.y) {
						context.setTextAlign('center')
						context.fillText(
							item.value,
							item.position.x,
							item.position.y - 4
						)
					} else {
						context.setTextAlign('center')
						context.fillText(
							item.value,
							item.position.x,
							item.position.y + fontSize + 2
						)
					}
				} else {
					//如果在左侧
					if (item.position.x < centerPosition.x) {
						context.setTextAlign('right')
						context.fillText(
							item.value,
							item.position.x - 4,
							item.position.y + fontSize / 2 - 2
						)
					} else {
						context.setTextAlign('left')
						context.fillText(
							item.value,
							item.position.x + 4,
							item.position.y + fontSize / 2 - 2
						)
					}
				}
			})
			context.closePath()
			context.stroke()
		})
		context.setTextAlign('left')
	}

	return {
		center: centerPosition,
		radius: radius,
		angleList: coordinateAngle,
	}
}

// 经纬度转墨卡托
function lonlat2mercator(longitude, latitude) {
	var mercator = Array(2)
	var x = (longitude * 20037508.34) / 180
	var y =
		Math.log(Math.tan(((90 + latitude) * Math.PI) / 360)) / (Math.PI / 180)
	y = (y * 20037508.34) / 180
	mercator[0] = x
	mercator[1] = y
	return mercator
}

// 墨卡托转经纬度
function mercator2lonlat(longitude, latitude) {
	var lonlat = Array(2)
	var x = (longitude / 20037508.34) * 180
	var y = (latitude / 20037508.34) * 180
	y =
		(180 / Math.PI) *
		(2 * Math.atan(Math.exp((y * Math.PI) / 180)) - Math.PI / 2)
	lonlat[0] = x
	lonlat[1] = y
	return lonlat
}

function getBoundingBox(data) {
	var bounds = {},
		coords
	bounds.xMin = 180
	bounds.xMax = 0
	bounds.yMin = 90
	bounds.yMax = 0
	for (var i = 0; i < data.length; i++) {
		var coorda = data[i].geometry.coordinates
		for (var k = 0; k < coorda.length; k++) {
			coords = coorda[k]
			if (coords.length == 1) {
				coords = coords[0]
			}
			for (var j = 0; j < coords.length; j++) {
				var longitude = coords[j][0]
				var latitude = coords[j][1]
				var point = {
					x: longitude,
					y: latitude,
				}
				bounds.xMin = bounds.xMin < point.x ? bounds.xMin : point.x
				bounds.xMax = bounds.xMax > point.x ? bounds.xMax : point.x
				bounds.yMin = bounds.yMin < point.y ? bounds.yMin : point.y
				bounds.yMax = bounds.yMax > point.y ? bounds.yMax : point.y
			}
		}
	}
	return bounds
}

function coordinateToPoint(
	latitude,
	longitude,
	bounds,
	scale,
	xoffset,
	yoffset
) {
	return {
		x: (longitude - bounds.xMin) * scale + xoffset,
		y: (bounds.yMax - latitude) * scale + yoffset,
	}
}

function pointToCoordinate(pointY, pointX, bounds, scale, xoffset, yoffset) {
	return {
		x: (pointX - xoffset) / scale + bounds.xMin,
		y: bounds.yMax - (pointY - yoffset) / scale,
	}
}

function isRayIntersectsSegment(poi, s_poi, e_poi) {
	if (s_poi[1] == e_poi[1]) {
		return false
	}
	if (s_poi[1] > poi[1] && e_poi[1] > poi[1]) {
		return false
	}
	if (s_poi[1] < poi[1] && e_poi[1] < poi[1]) {
		return false
	}
	if (s_poi[1] == poi[1] && e_poi[1] > poi[1]) {
		return false
	}
	if (e_poi[1] == poi[1] && s_poi[1] > poi[1]) {
		return false
	}
	if (s_poi[0] < poi[0] && e_poi[1] < poi[1]) {
		return false
	}
	let xseg =
		e_poi[0] -
		((e_poi[0] - s_poi[0]) * (e_poi[1] - poi[1])) / (e_poi[1] - s_poi[1])
	if (xseg < poi[0]) {
		return false
	} else {
		return true
	}
}

function isPoiWithinPoly(poi, poly, mercator) {
	let sinsc = 0
	for (let i = 0; i < poly.length; i++) {
		let epoly = poly[i][0]
		if (poly.length == 1) {
			epoly = poly[i][0]
		}
		for (let j = 0; j < epoly.length - 1; j++) {
			let s_poi = epoly[j]
			let e_poi = epoly[j + 1]
			if (mercator) {
				s_poi = lonlat2mercator(epoly[j][0], epoly[j][1])
				e_poi = lonlat2mercator(epoly[j + 1][0], epoly[j + 1][1])
			}
			if (isRayIntersectsSegment(poi, s_poi, e_poi)) {
				sinsc += 1
			}
		}
	}
	if (sinsc % 2 == 1) {
		return true
	} else {
		return false
	}
}

function drawMapDataPoints(series, opts, config, context) {
	var mapOption = assign(
		{},
		{
			border: true,
			mercator: false,
			borderWidth: 1,
			active: true,
			borderColor: '#666666',
			fillOpacity: 0.6,
			activeBorderColor: '#f04864',
			activeFillColor: '#facc14',
			activeFillOpacity: 1,
		},
		opts.extra.map
	)
	var coords, point
	var data = series
	var bounds = getBoundingBox(data)
	if (mapOption.mercator) {
		var max = lonlat2mercator(bounds.xMax, bounds.yMax)
		var min = lonlat2mercator(bounds.xMin, bounds.yMin)
		bounds.xMax = max[0]
		bounds.yMax = max[1]
		bounds.xMin = min[0]
		bounds.yMin = min[1]
	}
	var xScale = opts.width / Math.abs(bounds.xMax - bounds.xMin)
	var yScale = opts.height / Math.abs(bounds.yMax - bounds.yMin)
	var scale = xScale < yScale ? xScale : yScale
	var xoffset =
		opts.width / 2 - (Math.abs(bounds.xMax - bounds.xMin) / 2) * scale
	var yoffset =
		opts.height / 2 - (Math.abs(bounds.yMax - bounds.yMin) / 2) * scale
	for (var i = 0; i < data.length; i++) {
		context.beginPath()
		context.setLineWidth(mapOption.borderWidth * opts.pix)
		context.setStrokeStyle(mapOption.borderColor)
		context.setFillStyle(
			hexToRgb(
				series[i].color,
				series[i].fillOpacity || mapOption.fillOpacity
			)
		)
		if (mapOption.active == true && opts.tooltip) {
			if (opts.tooltip.index == i) {
				context.setStrokeStyle(mapOption.activeBorderColor)
				context.setFillStyle(
					hexToRgb(
						mapOption.activeFillColor,
						mapOption.activeFillOpacity
					)
				)
			}
		}
		var coorda = data[i].geometry.coordinates
		for (var k = 0; k < coorda.length; k++) {
			coords = coorda[k]
			if (coords.length == 1) {
				coords = coords[0]
			}
			for (var j = 0; j < coords.length; j++) {
				var gaosi = Array(2)
				if (mapOption.mercator) {
					gaosi = lonlat2mercator(coords[j][0], coords[j][1])
				} else {
					gaosi = coords[j]
				}
				point = coordinateToPoint(
					gaosi[1],
					gaosi[0],
					bounds,
					scale,
					xoffset,
					yoffset
				)
				if (j === 0) {
					context.beginPath()
					context.moveTo(point.x, point.y)
				} else {
					context.lineTo(point.x, point.y)
				}
			}
			context.fill()
			if (mapOption.border == true) {
				context.stroke()
			}
		}
	}
	if (opts.dataLabel == true) {
		for (var i = 0; i < data.length; i++) {
			var centerPoint = data[i].properties.centroid
			if (centerPoint) {
				if (mapOption.mercator) {
					centerPoint = lonlat2mercator(
						data[i].properties.centroid[0],
						data[i].properties.centroid[1]
					)
				}
				point = coordinateToPoint(
					centerPoint[1],
					centerPoint[0],
					bounds,
					scale,
					xoffset,
					yoffset
				)
				let fontSize = data[i].textSize * opts.pix || config.fontSize
				let fontColor = data[i].textColor || opts.fontColor
				if (
					mapOption.active &&
					mapOption.activeTextColor &&
					opts.tooltip &&
					opts.tooltip.index == i
				) {
					fontColor = mapOption.activeTextColor
				}
				let text = data[i].properties.name
				context.beginPath()
				context.setFontSize(fontSize)
				context.setFillStyle(fontColor)
				context.fillText(
					text,
					point.x - measureText(text, fontSize, context) / 2,
					point.y + fontSize / 2
				)
				context.closePath()
				context.stroke()
			}
		}
	}
	opts.chartData.mapData = {
		bounds: bounds,
		scale: scale,
		xoffset: xoffset,
		yoffset: yoffset,
		mercator: mapOption.mercator,
	}
	drawToolTipBridge(opts, config, context, 1)
	context.draw()
}

function normalInt(min, max, iter) {
	iter = iter == 0 ? 1 : iter
	var arr = []
	for (var i = 0; i < iter; i++) {
		arr[i] = Math.random()
	}
	return (
		Math.floor(
			(arr.reduce(function (i, j) {
				return i + j
			}) /
				iter) *
				(max - min)
		) + min
	)
}

function collisionNew(area, points, width, height) {
	var isIn = false
	for (let i = 0; i < points.length; i++) {
		if (points[i].area) {
			if (
				area[3] < points[i].area[1] ||
				area[0] > points[i].area[2] ||
				area[1] > points[i].area[3] ||
				area[2] < points[i].area[0]
			) {
				if (
					area[0] < 0 ||
					area[1] < 0 ||
					area[2] > width ||
					area[3] > height
				) {
					isIn = true
					break
				} else {
					isIn = false
				}
			} else {
				isIn = true
				break
			}
		}
	}
	return isIn
}

function getWordCloudPoint(opts, type, context) {
	let points = opts.series
	switch (type) {
		case 'normal':
			for (let i = 0; i < points.length; i++) {
				let text = points[i].name
				let tHeight = points[i].textSize * opts.pix
				let tWidth = measureText(text, tHeight, context)
				let x, y
				let area
				let breaknum = 0
				while (true) {
					breaknum++
					x =
						normalInt(-opts.width / 2, opts.width / 2, 5) -
						tWidth / 2
					y =
						normalInt(-opts.height / 2, opts.height / 2, 5) +
						tHeight / 2
					area = [
						x - 5 + opts.width / 2,
						y - 5 - tHeight + opts.height / 2,
						x + tWidth + 5 + opts.width / 2,
						y + 5 + opts.height / 2,
					]
					let isCollision = collisionNew(
						area,
						points,
						opts.width,
						opts.height
					)
					if (!isCollision) break
					if (breaknum == 1000) {
						area = [-100, -100, -100, -100]
						break
					}
				}
				points[i].area = area
			}
			break
		case 'vertical':
			function Spin() {
				//获取均匀随机值，是否旋转，旋转的概率为（1-0.5）
				if (Math.random() > 0.7) {
					return true
				} else {
					return false
				}
			}
			for (let i = 0; i < points.length; i++) {
				let text = points[i].name
				let tHeight = points[i].textSize * opts.pix
				let tWidth = measureText(text, tHeight, context)
				let isSpin = Spin()
				let x, y, area, areav
				let breaknum = 0
				while (true) {
					breaknum++
					let isCollision
					if (isSpin) {
						x =
							normalInt(-opts.width / 2, opts.width / 2, 5) -
							tWidth / 2
						y =
							normalInt(-opts.height / 2, opts.height / 2, 5) +
							tHeight / 2
						area = [
							y - 5 - tWidth + opts.width / 2,
							-x - 5 + opts.height / 2,
							y + 5 + opts.width / 2,
							-x + tHeight + 5 + opts.height / 2,
						]
						areav = [
							opts.width -
								(opts.width / 2 - opts.height / 2) -
								(-x + tHeight + 5 + opts.height / 2) -
								5,
							opts.height / 2 -
								opts.width / 2 +
								(y - 5 - tWidth + opts.width / 2) -
								5,
							opts.width -
								(opts.width / 2 - opts.height / 2) -
								(-x + tHeight + 5 + opts.height / 2) +
								tHeight,
							opts.height / 2 -
								opts.width / 2 +
								(y - 5 - tWidth + opts.width / 2) +
								tWidth +
								5,
						]
						isCollision = collisionNew(
							areav,
							points,
							opts.height,
							opts.width
						)
					} else {
						x =
							normalInt(-opts.width / 2, opts.width / 2, 5) -
							tWidth / 2
						y =
							normalInt(-opts.height / 2, opts.height / 2, 5) +
							tHeight / 2
						area = [
							x - 5 + opts.width / 2,
							y - 5 - tHeight + opts.height / 2,
							x + tWidth + 5 + opts.width / 2,
							y + 5 + opts.height / 2,
						]
						isCollision = collisionNew(
							area,
							points,
							opts.width,
							opts.height
						)
					}
					if (!isCollision) break
					if (breaknum == 1000) {
						area = [-1000, -1000, -1000, -1000]
						break
					}
				}
				if (isSpin) {
					points[i].area = areav
					points[i].areav = area
				} else {
					points[i].area = area
				}
				points[i].rotate = isSpin
			}
			break
	}
	return points
}

function drawWordCloudDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let wordOption = assign(
		{},
		{
			type: 'normal',
			autoColors: true,
		},
		opts.extra.word
	)
	if (!opts.chartData.wordCloudData) {
		opts.chartData.wordCloudData = getWordCloudPoint(
			opts,
			wordOption.type,
			context
		)
	}
	context.beginPath()
	context.setFillStyle(opts.background)
	context.rect(0, 0, opts.width, opts.height)
	context.fill()
	context.save()
	let points = opts.chartData.wordCloudData
	context.translate(opts.width / 2, opts.height / 2)
	for (let i = 0; i < points.length; i++) {
		context.save()
		if (points[i].rotate) {
			context.rotate((90 * Math.PI) / 180)
		}
		let text = points[i].name
		let tHeight = points[i].textSize * opts.pix
		let tWidth = measureText(text, tHeight, context)
		context.beginPath()
		context.setStrokeStyle(points[i].color)
		context.setFillStyle(points[i].color)
		context.setFontSize(tHeight)
		if (points[i].rotate) {
			if (points[i].areav[0] > 0) {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.strokeText(
							text,
							(points[i].areav[0] + 5 - opts.width / 2) *
								process -
								(tWidth * (1 - process)) / 2,
							(points[i].areav[1] +
								5 +
								tHeight -
								opts.height / 2) *
								process
						)
					} else {
						context.fillText(
							text,
							(points[i].areav[0] + 5 - opts.width / 2) *
								process -
								(tWidth * (1 - process)) / 2,
							(points[i].areav[1] +
								5 +
								tHeight -
								opts.height / 2) *
								process
						)
					}
				} else {
					context.fillText(
						text,
						(points[i].areav[0] + 5 - opts.width / 2) * process -
							(tWidth * (1 - process)) / 2,
						(points[i].areav[1] + 5 + tHeight - opts.height / 2) *
							process
					)
				}
			}
		} else {
			if (points[i].area[0] > 0) {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.strokeText(
							text,
							(points[i].area[0] + 5 - opts.width / 2) * process -
								(tWidth * (1 - process)) / 2,
							(points[i].area[1] +
								5 +
								tHeight -
								opts.height / 2) *
								process
						)
					} else {
						context.fillText(
							text,
							(points[i].area[0] + 5 - opts.width / 2) * process -
								(tWidth * (1 - process)) / 2,
							(points[i].area[1] +
								5 +
								tHeight -
								opts.height / 2) *
								process
						)
					}
				} else {
					context.fillText(
						text,
						(points[i].area[0] + 5 - opts.width / 2) * process -
							(tWidth * (1 - process)) / 2,
						(points[i].area[1] + 5 + tHeight - opts.height / 2) *
							process
					)
				}
			}
		}
		context.stroke()
		context.restore()
	}
	context.restore()
}

function drawFunnelDataPoints(series, opts, config, context) {
	let process =
		arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 1
	let funnelOption = assign(
		{},
		{
			type: 'funnel',
			activeWidth: 10,
			activeOpacity: 0.3,
			border: false,
			borderWidth: 2,
			borderColor: '#FFFFFF',
			fillOpacity: 1,
			minSize: 0,
			labelAlign: 'right',
			linearType: 'none',
			customColor: [],
		},
		opts.extra.funnel
	)
	let eachSpacing =
		(opts.height - opts.area[0] - opts.area[2]) / series.length
	let centerPosition = {
		x: opts.area[3] + (opts.width - opts.area[1] - opts.area[3]) / 2,
		y: opts.height - opts.area[2],
	}
	let activeWidth = funnelOption.activeWidth * opts.pix
	let radius = Math.min(
		(opts.width - opts.area[1] - opts.area[3]) / 2 - activeWidth,
		(opts.height - opts.area[0] - opts.area[2]) / 2 - activeWidth
	)
	let seriesNew = getFunnelDataPoints(
		series,
		radius,
		funnelOption,
		eachSpacing,
		process
	)
	context.save()
	context.translate(centerPosition.x, centerPosition.y)
	funnelOption.customColor = fillCustomColor(
		funnelOption.linearType,
		funnelOption.customColor,
		series,
		config
	)
	if (funnelOption.type == 'pyramid') {
		for (let i = 0; i < seriesNew.length; i++) {
			if (i == seriesNew.length - 1) {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.beginPath()
						context.setFillStyle(
							hexToRgb(
								seriesNew[i].color,
								funnelOption.activeOpacity
							)
						)
						context.moveTo(-activeWidth, -eachSpacing)
						context.lineTo(-seriesNew[i].radius - activeWidth, 0)
						context.lineTo(seriesNew[i].radius + activeWidth, 0)
						context.lineTo(activeWidth, -eachSpacing)
						context.lineTo(-activeWidth, -eachSpacing)
						context.closePath()
						context.fill()
					}
				}
				seriesNew[i].funnelArea = [
					centerPosition.x - seriesNew[i].radius,
					centerPosition.y - eachSpacing * (i + 1),
					centerPosition.x + seriesNew[i].radius,
					centerPosition.y - eachSpacing * i,
				]
				context.beginPath()
				context.setLineWidth(funnelOption.borderWidth * opts.pix)
				context.setStrokeStyle(funnelOption.borderColor)
				var fillColor = hexToRgb(
					seriesNew[i].color,
					funnelOption.fillOpacity
				)
				if (funnelOption.linearType == 'custom') {
					var grd = context.createLinearGradient(
						seriesNew[i].radius,
						-eachSpacing,
						-seriesNew[i].radius,
						-eachSpacing
					)
					grd.addColorStop(
						0,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					grd.addColorStop(
						0.5,
						hexToRgb(
							funnelOption.customColor[seriesNew[i].linearIndex],
							funnelOption.fillOpacity
						)
					)
					grd.addColorStop(
						1,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					fillColor = grd
				}
				context.setFillStyle(fillColor)
				context.moveTo(0, -eachSpacing)
				context.lineTo(-seriesNew[i].radius, 0)
				context.lineTo(seriesNew[i].radius, 0)
				context.lineTo(0, -eachSpacing)
				context.closePath()
				context.fill()
				if (funnelOption.border == true) {
					context.stroke()
				}
			} else {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.beginPath()
						context.setFillStyle(
							hexToRgb(
								seriesNew[i].color,
								funnelOption.activeOpacity
							)
						)
						context.moveTo(0, 0)
						context.lineTo(-seriesNew[i].radius - activeWidth, 0)
						context.lineTo(
							-seriesNew[i + 1].radius - activeWidth,
							-eachSpacing
						)
						context.lineTo(
							seriesNew[i + 1].radius + activeWidth,
							-eachSpacing
						)
						context.lineTo(seriesNew[i].radius + activeWidth, 0)
						context.lineTo(0, 0)
						context.closePath()
						context.fill()
					}
				}
				seriesNew[i].funnelArea = [
					centerPosition.x - seriesNew[i].radius,
					centerPosition.y - eachSpacing * (i + 1),
					centerPosition.x + seriesNew[i].radius,
					centerPosition.y - eachSpacing * i,
				]
				context.beginPath()
				context.setLineWidth(funnelOption.borderWidth * opts.pix)
				context.setStrokeStyle(funnelOption.borderColor)
				var fillColor = hexToRgb(
					seriesNew[i].color,
					funnelOption.fillOpacity
				)
				if (funnelOption.linearType == 'custom') {
					var grd = context.createLinearGradient(
						seriesNew[i].radius,
						-eachSpacing,
						-seriesNew[i].radius,
						-eachSpacing
					)
					grd.addColorStop(
						0,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					grd.addColorStop(
						0.5,
						hexToRgb(
							funnelOption.customColor[seriesNew[i].linearIndex],
							funnelOption.fillOpacity
						)
					)
					grd.addColorStop(
						1,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					fillColor = grd
				}
				context.setFillStyle(fillColor)
				context.moveTo(0, 0)
				context.lineTo(-seriesNew[i].radius, 0)
				context.lineTo(-seriesNew[i + 1].radius, -eachSpacing)
				context.lineTo(seriesNew[i + 1].radius, -eachSpacing)
				context.lineTo(seriesNew[i].radius, 0)
				context.lineTo(0, 0)
				context.closePath()
				context.fill()
				if (funnelOption.border == true) {
					context.stroke()
				}
			}
			context.translate(0, -eachSpacing)
		}
	} else {
		context.translate(0, -(seriesNew.length - 1) * eachSpacing)
		for (let i = 0; i < seriesNew.length; i++) {
			if (i == seriesNew.length - 1) {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.beginPath()
						context.setFillStyle(
							hexToRgb(
								seriesNew[i].color,
								funnelOption.activeOpacity
							)
						)
						context.moveTo(
							-activeWidth - funnelOption.minSize / 2,
							0
						)
						context.lineTo(
							-seriesNew[i].radius - activeWidth,
							-eachSpacing
						)
						context.lineTo(
							seriesNew[i].radius + activeWidth,
							-eachSpacing
						)
						context.lineTo(
							activeWidth + funnelOption.minSize / 2,
							0
						)
						context.lineTo(
							-activeWidth - funnelOption.minSize / 2,
							0
						)
						context.closePath()
						context.fill()
					}
				}
				seriesNew[i].funnelArea = [
					centerPosition.x - seriesNew[i].radius,
					centerPosition.y - eachSpacing,
					centerPosition.x + seriesNew[i].radius,
					centerPosition.y,
				]
				context.beginPath()
				context.setLineWidth(funnelOption.borderWidth * opts.pix)
				context.setStrokeStyle(funnelOption.borderColor)
				var fillColor = hexToRgb(
					seriesNew[i].color,
					funnelOption.fillOpacity
				)
				if (funnelOption.linearType == 'custom') {
					var grd = context.createLinearGradient(
						seriesNew[i].radius,
						-eachSpacing,
						-seriesNew[i].radius,
						-eachSpacing
					)
					grd.addColorStop(
						0,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					grd.addColorStop(
						0.5,
						hexToRgb(
							funnelOption.customColor[seriesNew[i].linearIndex],
							funnelOption.fillOpacity
						)
					)
					grd.addColorStop(
						1,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					fillColor = grd
				}
				context.setFillStyle(fillColor)
				context.moveTo(0, 0)
				context.lineTo(-funnelOption.minSize / 2, 0)
				context.lineTo(-seriesNew[i].radius, -eachSpacing)
				context.lineTo(seriesNew[i].radius, -eachSpacing)
				context.lineTo(funnelOption.minSize / 2, 0)
				context.lineTo(0, 0)
				context.closePath()
				context.fill()
				if (funnelOption.border == true) {
					context.stroke()
				}
			} else {
				if (opts.tooltip) {
					if (opts.tooltip.index == i) {
						context.beginPath()
						context.setFillStyle(
							hexToRgb(
								seriesNew[i].color,
								funnelOption.activeOpacity
							)
						)
						context.moveTo(0, 0)
						context.lineTo(
							-seriesNew[i + 1].radius - activeWidth,
							0
						)
						context.lineTo(
							-seriesNew[i].radius - activeWidth,
							-eachSpacing
						)
						context.lineTo(
							seriesNew[i].radius + activeWidth,
							-eachSpacing
						)
						context.lineTo(seriesNew[i + 1].radius + activeWidth, 0)
						context.lineTo(0, 0)
						context.closePath()
						context.fill()
					}
				}
				seriesNew[i].funnelArea = [
					centerPosition.x - seriesNew[i].radius,
					centerPosition.y - eachSpacing * (seriesNew.length - i),
					centerPosition.x + seriesNew[i].radius,
					centerPosition.y - eachSpacing * (seriesNew.length - i - 1),
				]
				context.beginPath()
				context.setLineWidth(funnelOption.borderWidth * opts.pix)
				context.setStrokeStyle(funnelOption.borderColor)
				var fillColor = hexToRgb(
					seriesNew[i].color,
					funnelOption.fillOpacity
				)
				if (funnelOption.linearType == 'custom') {
					var grd = context.createLinearGradient(
						seriesNew[i].radius,
						-eachSpacing,
						-seriesNew[i].radius,
						-eachSpacing
					)
					grd.addColorStop(
						0,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					grd.addColorStop(
						0.5,
						hexToRgb(
							funnelOption.customColor[seriesNew[i].linearIndex],
							funnelOption.fillOpacity
						)
					)
					grd.addColorStop(
						1,
						hexToRgb(seriesNew[i].color, funnelOption.fillOpacity)
					)
					fillColor = grd
				}
				context.setFillStyle(fillColor)
				context.moveTo(0, 0)
				context.lineTo(-seriesNew[i + 1].radius, 0)
				context.lineTo(-seriesNew[i].radius, -eachSpacing)
				context.lineTo(seriesNew[i].radius, -eachSpacing)
				context.lineTo(seriesNew[i + 1].radius, 0)
				context.lineTo(0, 0)
				context.closePath()
				context.fill()
				if (funnelOption.border == true) {
					context.stroke()
				}
			}
			context.translate(0, eachSpacing)
		}
	}

	context.restore()
	if (opts.dataLabel !== false && process === 1) {
		drawFunnelText(
			seriesNew,
			opts,
			context,
			eachSpacing,
			funnelOption.labelAlign,
			activeWidth,
			centerPosition
		)
	}
	if (process === 1) {
		drawFunnelCenterText(
			seriesNew,
			opts,
			context,
			eachSpacing,
			funnelOption.labelAlign,
			activeWidth,
			centerPosition
		)
	}
	return {
		center: centerPosition,
		radius: radius,
		series: seriesNew,
	}
}

function drawFunnelText(
	series,
	opts,
	context,
	eachSpacing,
	labelAlign,
	activeWidth,
	centerPosition
) {
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		if (item.labelShow === false) {
			continue
		}
		let startX, endX, startY, fontSize
		let text = item.formatter
			? item.formatter(item, i, series, opts)
			: util.toFixed(item._proportion_ * 100) + '%'
		text = item.labelText ? item.labelText : text
		if (labelAlign == 'right') {
			if (i == series.length - 1) {
				startX = (item.funnelArea[2] + centerPosition.x) / 2
			} else {
				startX = (item.funnelArea[2] + series[i + 1].funnelArea[2]) / 2
			}
			endX = startX + activeWidth * 2
			startY = item.funnelArea[1] + eachSpacing / 2
			fontSize = item.textSize * opts.pix || opts.fontSize * opts.pix
			context.setLineWidth(1 * opts.pix)
			context.setStrokeStyle(item.color)
			context.setFillStyle(item.color)
			context.beginPath()
			context.moveTo(startX, startY)
			context.lineTo(endX, startY)
			context.stroke()
			context.closePath()
			context.beginPath()
			context.moveTo(endX, startY)
			context.arc(endX, startY, 2 * opts.pix, 0, 2 * Math.PI)
			context.closePath()
			context.fill()
			context.beginPath()
			context.setFontSize(fontSize)
			context.setFillStyle(item.textColor || opts.fontColor)
			context.fillText(text, endX + 5, startY + fontSize / 2 - 2)
			context.closePath()
			context.stroke()
			context.closePath()
		}
		if (labelAlign == 'left') {
			if (i == series.length - 1) {
				startX = (item.funnelArea[0] + centerPosition.x) / 2
			} else {
				startX = (item.funnelArea[0] + series[i + 1].funnelArea[0]) / 2
			}
			endX = startX - activeWidth * 2
			startY = item.funnelArea[1] + eachSpacing / 2
			fontSize = item.textSize * opts.pix || opts.fontSize * opts.pix
			context.setLineWidth(1 * opts.pix)
			context.setStrokeStyle(item.color)
			context.setFillStyle(item.color)
			context.beginPath()
			context.moveTo(startX, startY)
			context.lineTo(endX, startY)
			context.stroke()
			context.closePath()
			context.beginPath()
			context.moveTo(endX, startY)
			context.arc(endX, startY, 2, 0, 2 * Math.PI)
			context.closePath()
			context.fill()
			context.beginPath()
			context.setFontSize(fontSize)
			context.setFillStyle(item.textColor || opts.fontColor)
			context.fillText(
				text,
				endX - 5 - measureText(text, fontSize, context),
				startY + fontSize / 2 - 2
			)
			context.closePath()
			context.stroke()
			context.closePath()
		}
	}
}

function drawFunnelCenterText(
	series,
	opts,
	context,
	eachSpacing,
	labelAlign,
	activeWidth,
	centerPosition
) {
	for (let i = 0; i < series.length; i++) {
		let item = series[i]
		let startY, fontSize
		if (item.centerText) {
			startY = item.funnelArea[1] + eachSpacing / 2
			fontSize =
				item.centerTextSize * opts.pix || opts.fontSize * opts.pix
			context.beginPath()
			context.setFontSize(fontSize)
			context.setFillStyle(item.centerTextColor || '#FFFFFF')
			context.fillText(
				item.centerText,
				centerPosition.x -
					measureText(item.centerText, fontSize, context) / 2,
				startY + fontSize / 2 - 2
			)
			context.closePath()
			context.stroke()
			context.closePath()
		}
	}
}

function drawCanvas(opts, context) {
	context.save()
	context.translate(0, 0.5)
	context.restore()
	context.draw()
}

var Timing = {
	easeIn: function easeIn(pos) {
		return Math.pow(pos, 3)
	},
	easeOut: function easeOut(pos) {
		return Math.pow(pos - 1, 3) + 1
	},
	easeInOut: function easeInOut(pos) {
		if ((pos /= 0.5) < 1) {
			return 0.5 * Math.pow(pos, 3)
		} else {
			return 0.5 * (Math.pow(pos - 2, 3) + 2)
		}
	},
	linear: function linear(pos) {
		return pos
	},
}

function Animation(opts) {
	this.isStop = false
	opts.duration = typeof opts.duration === 'undefined' ? 1000 : opts.duration
	opts.timing = opts.timing || 'easeInOut'
	var delay = 17
	function createAnimationFrame() {
		if (typeof setTimeout !== 'undefined') {
			return function (step, delay) {
				setTimeout(function () {
					var timeStamp = +new Date()
					step(timeStamp)
				}, delay)
			}
		} else if (typeof requestAnimationFrame !== 'undefined') {
			return requestAnimationFrame
		} else {
			return function (step) {
				step(null)
			}
		}
	}
	var animationFrame = createAnimationFrame()
	var startTimeStamp = null
	var _step = function step(timestamp) {
		if (timestamp === null || this.isStop === true) {
			opts.onProcess && opts.onProcess(1)
			opts.onAnimationFinish && opts.onAnimationFinish()
			return
		}
		if (startTimeStamp === null) {
			startTimeStamp = timestamp
		}
		if (timestamp - startTimeStamp < opts.duration) {
			var process = (timestamp - startTimeStamp) / opts.duration
			var timingFunction = Timing[opts.timing]
			process = timingFunction(process)
			opts.onProcess && opts.onProcess(process)
			animationFrame(_step, delay)
		} else {
			opts.onProcess && opts.onProcess(1)
			opts.onAnimationFinish && opts.onAnimationFinish()
		}
	}
	_step = _step.bind(this)
	animationFrame(_step, delay)
}

Animation.prototype.stop = function () {
	this.isStop = true
}

function drawCharts(type, opts, config, context) {
	var _this = this
	var series = opts.series
	//兼容ECharts饼图类数据格式
	if (
		type === 'pie' ||
		type === 'ring' ||
		type === 'mount' ||
		type === 'rose' ||
		type === 'funnel'
	) {
		series = fixPieSeries(series, opts, config)
	}
	var categories = opts.categories
	if (type === 'mount') {
		categories = []
		for (let j = 0; j < series.length; j++) {
			if (series[j].show !== false) categories.push(series[j].name)
		}
		opts.categories = categories
	}
	series = fillSeries(series, opts, config)
	var duration = opts.animation ? opts.duration : 0
	_this.animationInstance && _this.animationInstance.stop()
	var seriesMA = null
	if (type == 'candle') {
		let average = assign({}, opts.extra.candle.average)
		if (average.show) {
			seriesMA = calCandleMA(
				average.day,
				average.name,
				average.color,
				series[0].data
			)
			seriesMA = fillSeries(seriesMA, opts, config)
			opts.seriesMA = seriesMA
		} else if (opts.seriesMA) {
			seriesMA = opts.seriesMA = fillSeries(opts.seriesMA, opts, config)
		} else {
			seriesMA = series
		}
	} else {
		seriesMA = series
	}
	/* 过滤掉show=false的series */
	opts._series_ = series = filterSeries(series)
	//重新计算图表区域
	opts.area = new Array(4)
	//复位绘图区域
	for (let j = 0; j < 4; j++) {
		opts.area[j] = opts.padding[j] * opts.pix
	}
	//通过计算三大区域：图例、X轴、Y轴的大小，确定绘图区域
	var _calLegendData = calLegendData(
			seriesMA,
			opts,
			config,
			opts.chartData,
			context
		),
		legendHeight = _calLegendData.area.wholeHeight,
		legendWidth = _calLegendData.area.wholeWidth

	switch (opts.legend.position) {
		case 'top':
			opts.area[0] += legendHeight
			break
		case 'bottom':
			opts.area[2] += legendHeight
			break
		case 'left':
			opts.area[3] += legendWidth
			break
		case 'right':
			opts.area[1] += legendWidth
			break
	}

	let _calYAxisData = {},
		yAxisWidth = 0
	if (
		opts.type === 'line' ||
		opts.type === 'column' ||
		opts.type === 'mount' ||
		opts.type === 'area' ||
		opts.type === 'mix' ||
		opts.type === 'candle' ||
		opts.type === 'scatter' ||
		opts.type === 'bubble' ||
		opts.type === 'bar'
	) {
		_calYAxisData = calYAxisData(series, opts, config, context)
		yAxisWidth = _calYAxisData.yAxisWidth
		//如果显示Y轴标题
		if (opts.yAxis.showTitle) {
			let maxTitleHeight = 0
			for (let i = 0; i < opts.yAxis.data.length; i++) {
				maxTitleHeight = Math.max(
					maxTitleHeight,
					opts.yAxis.data[i].titleFontSize
						? opts.yAxis.data[i].titleFontSize * opts.pix
						: config.fontSize
				)
			}
			opts.area[0] += maxTitleHeight
		}
		let rightIndex = 0,
			leftIndex = 0
		//计算主绘图区域左右位置
		for (let i = 0; i < yAxisWidth.length; i++) {
			if (yAxisWidth[i].position == 'left') {
				if (leftIndex > 0) {
					opts.area[3] +=
						yAxisWidth[i].width + opts.yAxis.padding * opts.pix
				} else {
					opts.area[3] += yAxisWidth[i].width
				}
				leftIndex += 1
			} else if (yAxisWidth[i].position == 'right') {
				if (rightIndex > 0) {
					opts.area[1] +=
						yAxisWidth[i].width + opts.yAxis.padding * opts.pix
				} else {
					opts.area[1] += yAxisWidth[i].width
				}
				rightIndex += 1
			}
		}
	} else {
		config.yAxisWidth = yAxisWidth
	}
	opts.chartData.yAxisData = _calYAxisData

	if (
		opts.categories &&
		opts.categories.length &&
		opts.type !== 'radar' &&
		opts.type !== 'gauge' &&
		opts.type !== 'bar'
	) {
		opts.chartData.xAxisData = getXAxisPoints(opts.categories, opts, config)
		let _calCategoriesData = calCategoriesData(
				opts.categories,
				opts,
				config,
				opts.chartData.xAxisData.eachSpacing,
				context
			),
			xAxisHeight = _calCategoriesData.xAxisHeight,
			angle = _calCategoriesData.angle
		config.xAxisHeight = xAxisHeight
		config._xAxisTextAngle_ = angle
		opts.area[2] += xAxisHeight
		opts.chartData.categoriesData = _calCategoriesData
	} else {
		if (
			opts.type === 'line' ||
			opts.type === 'area' ||
			opts.type === 'scatter' ||
			opts.type === 'bubble' ||
			opts.type === 'bar'
		) {
			opts.chartData.xAxisData = calXAxisData(
				series,
				opts,
				config,
				context
			)
			categories = opts.chartData.xAxisData.rangesFormat
			let _calCategoriesData = calCategoriesData(
					categories,
					opts,
					config,
					opts.chartData.xAxisData.eachSpacing,
					context
				),
				xAxisHeight = _calCategoriesData.xAxisHeight,
				angle = _calCategoriesData.angle
			config.xAxisHeight = xAxisHeight
			config._xAxisTextAngle_ = angle
			opts.area[2] += xAxisHeight
			opts.chartData.categoriesData = _calCategoriesData
		} else {
			opts.chartData.xAxisData = {
				xAxisPoints: [],
			}
		}
	}

	//计算右对齐偏移距离
	if (
		opts.enableScroll &&
		opts.xAxis.scrollAlign == 'right' &&
		opts._scrollDistance_ === undefined
	) {
		let offsetLeft = 0,
			xAxisPoints = opts.chartData.xAxisData.xAxisPoints,
			startX = opts.chartData.xAxisData.startX,
			endX = opts.chartData.xAxisData.endX,
			eachSpacing = opts.chartData.xAxisData.eachSpacing
		let totalWidth = eachSpacing * (xAxisPoints.length - 1)
		let screenWidth = endX - startX
		offsetLeft = screenWidth - totalWidth
		_this.scrollOption.currentOffset = offsetLeft
		_this.scrollOption.startTouchX = offsetLeft
		_this.scrollOption.distance = 0
		_this.scrollOption.lastMoveTime = 0
		opts._scrollDistance_ = offsetLeft
	}

	if (type === 'pie' || type === 'ring' || type === 'rose') {
		config._pieTextMaxLength_ =
			opts.dataLabel === false
				? 0
				: getPieTextMaxLength(seriesMA, config, context, opts)
	}

	switch (type) {
		case 'word':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function (process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawWordCloudDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'map':
			context.clearRect(0, 0, opts.width, opts.height)
			drawMapDataPoints(series, opts, config, context)
			setTimeout(() => {
				this.uevent.trigger('renderComplete')
			}, 50)
			break
		case 'funnel':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function (process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.funnelData = drawFunnelDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(opts, config, context, process)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'line':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawLineDataPoints = drawLineDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawLineDataPoints.xAxisPoints,
						calPoints = _drawLineDataPoints.calPoints,
						eachSpacing = _drawLineDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'scatter':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawScatterDataPoints = drawScatterDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawScatterDataPoints.xAxisPoints,
						calPoints = _drawScatterDataPoints.calPoints,
						eachSpacing = _drawScatterDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'bubble':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawBubbleDataPoints = drawBubbleDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawBubbleDataPoints.xAxisPoints,
						calPoints = _drawBubbleDataPoints.calPoints,
						eachSpacing = _drawBubbleDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'mix':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawMixDataPoints = drawMixDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawMixDataPoints.xAxisPoints,
						calPoints = _drawMixDataPoints.calPoints,
						eachSpacing = _drawMixDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'column':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawColumnDataPoints = drawColumnDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawColumnDataPoints.xAxisPoints,
						calPoints = _drawColumnDataPoints.calPoints,
						eachSpacing = _drawColumnDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'mount':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawMountDataPoints = drawMountDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawMountDataPoints.xAxisPoints,
						calPoints = _drawMountDataPoints.calPoints,
						eachSpacing = _drawMountDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'bar':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawXAxis(categories, opts, config, context)
					var _drawBarDataPoints = drawBarDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						yAxisPoints = _drawBarDataPoints.yAxisPoints,
						calPoints = _drawBarDataPoints.calPoints,
						eachSpacing = _drawBarDataPoints.eachSpacing
					opts.chartData.yAxisPoints = yAxisPoints
					opts.chartData.xAxisPoints =
						opts.chartData.xAxisData.xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						yAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'area':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawAreaDataPoints = drawAreaDataPoints(
							series,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawAreaDataPoints.xAxisPoints,
						calPoints = _drawAreaDataPoints.calPoints,
						eachSpacing = _drawAreaDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'ring':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.pieData = drawPieDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(opts, config, context, process)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'pie':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.pieData = drawPieDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(opts, config, context, process)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'rose':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.pieData = drawRoseDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(opts, config, context, process)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'radar':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.radarData = drawRadarDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawLegend(
						opts.series,
						opts,
						config,
						context,
						opts.chartData
					)
					drawToolTipBridge(opts, config, context, process)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'arcbar':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.arcbarData = drawArcbarDataPoints(
						series,
						opts,
						config,
						context,
						process
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'gauge':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					opts.chartData.gaugeData = drawGaugeDataPoints(
						categories,
						series,
						opts,
						config,
						context,
						process
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
		case 'candle':
			this.animationInstance = new Animation({
				timing: opts.timing,
				duration: duration,
				onProcess: function onProcess(process) {
					context.clearRect(0, 0, opts.width, opts.height)
					if (opts.rotate) {
						contextRotate(context, opts)
					}
					drawYAxisGrid(categories, opts, config, context)
					drawXAxis(categories, opts, config, context)
					var _drawCandleDataPoints = drawCandleDataPoints(
							series,
							seriesMA,
							opts,
							config,
							context,
							process
						),
						xAxisPoints = _drawCandleDataPoints.xAxisPoints,
						calPoints = _drawCandleDataPoints.calPoints,
						eachSpacing = _drawCandleDataPoints.eachSpacing
					opts.chartData.xAxisPoints = xAxisPoints
					opts.chartData.calPoints = calPoints
					opts.chartData.eachSpacing = eachSpacing
					drawYAxis(series, opts, config, context)
					if (opts.enableMarkLine !== false && process === 1) {
						drawMarkLine(opts, config, context)
					}
					if (seriesMA) {
						drawLegend(
							seriesMA,
							opts,
							config,
							context,
							opts.chartData
						)
					} else {
						drawLegend(
							opts.series,
							opts,
							config,
							context,
							opts.chartData
						)
					}
					drawToolTipBridge(
						opts,
						config,
						context,
						process,
						eachSpacing,
						xAxisPoints
					)
					drawCanvas(opts, context)
				},
				onAnimationFinish: function onAnimationFinish() {
					_this.uevent.trigger('renderComplete')
				},
			})
			break
	}
}

function uChartsEvent() {
	this.events = {}
}

uChartsEvent.prototype.addEventListener = function (type, listener) {
	this.events[type] = this.events[type] || []
	this.events[type].push(listener)
}

uChartsEvent.prototype.delEventListener = function (type) {
	this.events[type] = []
}

uChartsEvent.prototype.trigger = function () {
	for (
		var _len = arguments.length, args = Array(_len), _key = 0;
		_key < _len;
		_key++
	) {
		args[_key] = arguments[_key]
	}
	var type = args[0]
	var params = args.slice(1)
	if (!!this.events[type]) {
		this.events[type].forEach(function (listener) {
			try {
				listener.apply(null, params)
			} catch (e) {
				//console.log('[uCharts] '+e);
			}
		})
	}
}

var uCharts = function uCharts(opts) {
	opts.pix = opts.pixelRatio ? opts.pixelRatio : 1
	opts.fontSize = opts.fontSize ? opts.fontSize : 13
	opts.fontColor = opts.fontColor ? opts.fontColor : config.fontColor
	if (opts.background == '' || opts.background == 'none') {
		opts.background = '#FFFFFF'
	}
	opts.title = assign({}, opts.title)
	opts.subtitle = assign({}, opts.subtitle)
	opts.duration = opts.duration ? opts.duration : 1000
	opts.yAxis = assign(
		{},
		{
			data: [],
			showTitle: false,
			disabled: false,
			disableGrid: false,
			gridSet: 'number',
			splitNumber: 5,
			gridType: 'solid',
			dashLength: 4 * opts.pix,
			gridColor: '#cccccc',
			padding: 10,
			fontColor: '#666666',
		},
		opts.yAxis
	)
	opts.xAxis = assign(
		{},
		{
			rotateLabel: false,
			rotateAngle: 45,
			disabled: false,
			disableGrid: false,
			splitNumber: 5,
			calibration: false,
			fontColor: '#666666',
			fontSize: 13,
			lineHeight: 20,
			marginTop: 0,
			gridType: 'solid',
			dashLength: 4,
			scrollAlign: 'left',
			boundaryGap: 'center',
			axisLine: true,
			axisLineColor: '#cccccc',
			titleFontSize: 13,
			titleOffsetY: 0,
			titleOffsetX: 0,
			titleFontColor: '#666666',
		},
		opts.xAxis
	)
	opts.xAxis.scrollPosition = opts.xAxis.scrollAlign
	opts.legend = assign(
		{},
		{
			show: true,
			position: 'bottom',
			float: 'center',
			backgroundColor: 'rgba(0,0,0,0)',
			borderColor: 'rgba(0,0,0,0)',
			borderWidth: 0,
			padding: 5,
			margin: 5,
			itemGap: 10,
			fontSize: opts.fontSize,
			lineHeight: opts.fontSize,
			fontColor: opts.fontColor,
			formatter: {},
			hiddenColor: '#CECECE',
		},
		opts.legend
	)
	opts.extra = assign(
		{
			tooltip: {
				legendShape: 'auto',
			},
		},
		opts.extra
	)
	opts.rotate = opts.rotate ? true : false
	opts.animation = opts.animation ? true : false
	opts.rotate = opts.rotate ? true : false
	opts.canvas2d = opts.canvas2d ? true : false

	let config$$1 = assign({}, config)
	config$$1.color = opts.color ? opts.color : config$$1.color
	if (opts.type == 'pie') {
		config$$1.pieChartLinePadding =
			opts.dataLabel === false
				? 0
				: opts.extra.pie.labelWidth * opts.pix ||
				  config$$1.pieChartLinePadding * opts.pix
	}
	if (opts.type == 'ring') {
		config$$1.pieChartLinePadding =
			opts.dataLabel === false
				? 0
				: opts.extra.ring.labelWidth * opts.pix ||
				  config$$1.pieChartLinePadding * opts.pix
	}
	if (opts.type == 'rose') {
		config$$1.pieChartLinePadding =
			opts.dataLabel === false
				? 0
				: opts.extra.rose.labelWidth * opts.pix ||
				  config$$1.pieChartLinePadding * opts.pix
	}
	config$$1.pieChartTextPadding =
		opts.dataLabel === false ? 0 : config$$1.pieChartTextPadding * opts.pix

	//屏幕旋转
	config$$1.rotate = opts.rotate
	if (opts.rotate) {
		let tempWidth = opts.width
		let tempHeight = opts.height
		opts.width = tempHeight
		opts.height = tempWidth
	}

	//适配高分屏
	opts.padding = opts.padding ? opts.padding : config$$1.padding
	config$$1.yAxisWidth = config.yAxisWidth * opts.pix
	config$$1.fontSize = opts.fontSize * opts.pix
	config$$1.titleFontSize = config.titleFontSize * opts.pix
	config$$1.subtitleFontSize = config.subtitleFontSize * opts.pix
	if (!opts.context) {
		throw new Error(
			'[uCharts] 未获取到context！注意：v2.0版本后，需要自行获取canvas的绘图上下文并传入opts.context！'
		)
	}
	this.context = opts.context
	if (!this.context.setTextAlign) {
		this.context.setStrokeStyle = function (e) {
			return (this.strokeStyle = e)
		}
		this.context.setLineWidth = function (e) {
			return (this.lineWidth = e)
		}
		this.context.setLineCap = function (e) {
			return (this.lineCap = e)
		}
		this.context.setFontSize = function (e) {
			return (this.font = e + 'px sans-serif')
		}
		this.context.setFillStyle = function (e) {
			return (this.fillStyle = e)
		}
		this.context.setTextAlign = function (e) {
			return (this.textAlign = e)
		}
		this.context.setTextBaseline = function (e) {
			return (this.textBaseline = e)
		}
		this.context.setShadow = function (offsetX, offsetY, blur, color) {
			this.shadowColor = color
			this.shadowOffsetX = offsetX
			this.shadowOffsetY = offsetY
			this.shadowBlur = blur
		}
		this.context.draw = function () {}
	}
	//兼容NVUEsetLineDash
	if (!this.context.setLineDash) {
		this.context.setLineDash = function (e) {}
	}
	opts.chartData = {}
	this.uevent = new uChartsEvent()
	this.scrollOption = {
		currentOffset: 0,
		startTouchX: 0,
		distance: 0,
		lastMoveTime: 0,
	}
	this.opts = opts
	this.config = config$$1
	drawCharts.call(this, opts.type, opts, config$$1, this.context)
}

uCharts.prototype.updateData = function () {
	let data =
		arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}
	this.opts = assign({}, this.opts, data)
	this.opts.updateData = true
	let scrollPosition = data.scrollPosition || 'current'
	switch (scrollPosition) {
		case 'current':
			this.opts._scrollDistance_ = this.scrollOption.currentOffset
			break
		case 'left':
			this.opts._scrollDistance_ = 0
			this.scrollOption = {
				currentOffset: 0,
				startTouchX: 0,
				distance: 0,
				lastMoveTime: 0,
			}
			break
		case 'right':
			let _calYAxisData = calYAxisData(
					this.opts.series,
					this.opts,
					this.config,
					this.context
				),
				yAxisWidth = _calYAxisData.yAxisWidth
			this.config.yAxisWidth = yAxisWidth
			let offsetLeft = 0
			let _getXAxisPoints0 = getXAxisPoints(
					this.opts.categories,
					this.opts,
					this.config
				),
				xAxisPoints = _getXAxisPoints0.xAxisPoints,
				startX = _getXAxisPoints0.startX,
				endX = _getXAxisPoints0.endX,
				eachSpacing = _getXAxisPoints0.eachSpacing
			let totalWidth = eachSpacing * (xAxisPoints.length - 1)
			let screenWidth = endX - startX
			offsetLeft = screenWidth - totalWidth
			this.scrollOption = {
				currentOffset: offsetLeft,
				startTouchX: offsetLeft,
				distance: 0,
				lastMoveTime: 0,
			}
			this.opts._scrollDistance_ = offsetLeft
			break
	}
	drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.zoom = function () {
	var val =
		arguments.length > 0 && arguments[0] !== undefined
			? arguments[0]
			: this.opts.xAxis.itemCount
	if (this.opts.enableScroll !== true) {
		console.log('[uCharts] 请启用滚动条后使用')
		return
	}
	//当前屏幕中间点
	let centerPoint =
		Math.round(
			Math.abs(this.scrollOption.currentOffset) /
				this.opts.chartData.eachSpacing
		) + Math.round(this.opts.xAxis.itemCount / 2)
	this.opts.animation = false
	this.opts.xAxis.itemCount = val.itemCount
	//重新计算x轴偏移距离
	let _calYAxisData = calYAxisData(
			this.opts.series,
			this.opts,
			this.config,
			this.context
		),
		yAxisWidth = _calYAxisData.yAxisWidth
	this.config.yAxisWidth = yAxisWidth
	let offsetLeft = 0
	let _getXAxisPoints0 = getXAxisPoints(
			this.opts.categories,
			this.opts,
			this.config
		),
		xAxisPoints = _getXAxisPoints0.xAxisPoints,
		startX = _getXAxisPoints0.startX,
		endX = _getXAxisPoints0.endX,
		eachSpacing = _getXAxisPoints0.eachSpacing
	let centerLeft = eachSpacing * centerPoint
	let screenWidth = endX - startX
	let MaxLeft = screenWidth - eachSpacing * (xAxisPoints.length - 1)
	offsetLeft = screenWidth / 2 - centerLeft
	if (offsetLeft > 0) {
		offsetLeft = 0
	}
	if (offsetLeft < MaxLeft) {
		offsetLeft = MaxLeft
	}
	this.scrollOption = {
		currentOffset: offsetLeft,
		startTouchX: 0,
		distance: 0,
		lastMoveTime: 0,
	}
	calValidDistance(
		this,
		offsetLeft,
		this.opts.chartData,
		this.config,
		this.opts
	)
	this.opts._scrollDistance_ = offsetLeft
	drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.dobuleZoom = function (e) {
	if (this.opts.enableScroll !== true) {
		console.log('[uCharts] 请启用滚动条后使用')
		return
	}
	const tcs = e.changedTouches
	if (tcs.length < 2) {
		return
	}
	for (var i = 0; i < tcs.length; i++) {
		tcs[i].x = tcs[i].x ? tcs[i].x : tcs[i].clientX
		tcs[i].y = tcs[i].y ? tcs[i].y : tcs[i].clientY
	}
	const ntcs = [
		getTouches(tcs[0], this.opts, e),
		getTouches(tcs[1], this.opts, e),
	]
	const xlength = Math.abs(ntcs[0].x - ntcs[1].x)
	// 记录初始的两指之间的数据
	if (!this.scrollOption.moveCount) {
		let cts0 = {
			changedTouches: [
				{ x: tcs[0].x, y: this.opts.area[0] / this.opts.pix + 2 },
			],
		}
		let cts1 = {
			changedTouches: [
				{ x: tcs[1].x, y: this.opts.area[0] / this.opts.pix + 2 },
			],
		}
		if (this.opts.rotate) {
			cts0 = {
				changedTouches: [
					{
						x:
							this.opts.height / this.opts.pix -
							this.opts.area[0] / this.opts.pix -
							2,
						y: tcs[0].y,
					},
				],
			}
			cts1 = {
				changedTouches: [
					{
						x:
							this.opts.height / this.opts.pix -
							this.opts.area[0] / this.opts.pix -
							2,
						y: tcs[1].y,
					},
				],
			}
		}
		const moveCurrent1 = this.getCurrentDataIndex(cts0).index
		const moveCurrent2 = this.getCurrentDataIndex(cts1).index
		const moveCount = Math.abs(moveCurrent1 - moveCurrent2)
		this.scrollOption.moveCount = moveCount
		this.scrollOption.moveCurrent1 = Math.min(moveCurrent1, moveCurrent2)
		this.scrollOption.moveCurrent2 = Math.max(moveCurrent1, moveCurrent2)
		return
	}

	let currentEachSpacing = xlength / this.scrollOption.moveCount
	let itemCount =
		(this.opts.width - this.opts.area[1] - this.opts.area[3]) /
		currentEachSpacing
	itemCount = itemCount <= 2 ? 2 : itemCount
	itemCount =
		itemCount >= this.opts.categories.length
			? this.opts.categories.length
			: itemCount
	this.opts.animation = false
	this.opts.xAxis.itemCount = itemCount
	// 重新计算滚动条偏移距离
	let offsetLeft = 0
	let _getXAxisPoints0 = getXAxisPoints(
			this.opts.categories,
			this.opts,
			this.config
		),
		xAxisPoints = _getXAxisPoints0.xAxisPoints,
		startX = _getXAxisPoints0.startX,
		endX = _getXAxisPoints0.endX,
		eachSpacing = _getXAxisPoints0.eachSpacing
	let currentLeft = eachSpacing * this.scrollOption.moveCurrent1
	let screenWidth = endX - startX
	let MaxLeft = screenWidth - eachSpacing * (xAxisPoints.length - 1)
	offsetLeft =
		-currentLeft +
		Math.min(ntcs[0].x, ntcs[1].x) -
		this.opts.area[3] -
		eachSpacing
	if (offsetLeft > 0) {
		offsetLeft = 0
	}
	if (offsetLeft < MaxLeft) {
		offsetLeft = MaxLeft
	}
	this.scrollOption.currentOffset = offsetLeft
	this.scrollOption.startTouchX = 0
	this.scrollOption.distance = 0
	calValidDistance(
		this,
		offsetLeft,
		this.opts.chartData,
		this.config,
		this.opts
	)
	this.opts._scrollDistance_ = offsetLeft
	drawCharts.call(this, this.opts.type, this.opts, this.config, this.context)
}

uCharts.prototype.stopAnimation = function () {
	this.animationInstance && this.animationInstance.stop()
}

uCharts.prototype.addEventListener = function (type, listener) {
	this.uevent.addEventListener(type, listener)
}

uCharts.prototype.delEventListener = function (type) {
	this.uevent.delEventListener(type)
}

uCharts.prototype.getCurrentDataIndex = function (e) {
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	if (touches) {
		let _touches$ = getTouches(touches, this.opts, e)
		if (this.opts.type === 'pie' || this.opts.type === 'ring') {
			return findPieChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.pieData,
				this.opts
			)
		} else if (this.opts.type === 'rose') {
			return findRoseChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.pieData,
				this.opts
			)
		} else if (this.opts.type === 'radar') {
			return findRadarChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.radarData,
				this.opts.categories.length
			)
		} else if (this.opts.type === 'funnel') {
			return findFunnelChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.funnelData
			)
		} else if (this.opts.type === 'map') {
			return findMapChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts
			)
		} else if (this.opts.type === 'word') {
			return findWordChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.wordCloudData
			)
		} else if (this.opts.type === 'bar') {
			return findBarChartCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.calPoints,
				this.opts,
				this.config,
				Math.abs(this.scrollOption.currentOffset)
			)
		} else {
			return findCurrentIndex(
				{
					x: _touches$.x,
					y: _touches$.y,
				},
				this.opts.chartData.calPoints,
				this.opts,
				this.config,
				Math.abs(this.scrollOption.currentOffset)
			)
		}
	}
	return -1
}

uCharts.prototype.getLegendDataIndex = function (e) {
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	if (touches) {
		let _touches$ = getTouches(touches, this.opts, e)
		return findLegendIndex(
			{
				x: _touches$.x,
				y: _touches$.y,
			},
			this.opts.chartData.legendData
		)
	}
	return -1
}

uCharts.prototype.touchLegend = function (e) {
	var option =
		arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	if (touches) {
		var _touches$ = getTouches(touches, this.opts, e)
		var index = this.getLegendDataIndex(e)
		if (index >= 0) {
			if (this.opts.type == 'candle') {
				this.opts.seriesMA[index].show = !this.opts.seriesMA[index].show
			} else {
				this.opts.series[index].show = !this.opts.series[index].show
			}
			this.opts.animation = option.animation ? true : false
			this.opts._scrollDistance_ = this.scrollOption.currentOffset
			drawCharts.call(
				this,
				this.opts.type,
				this.opts,
				this.config,
				this.context
			)
		}
	}
}

uCharts.prototype.showToolTip = function (e) {
	var option =
		arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	if (!touches) {
		console.log('[uCharts] 未获取到event坐标信息')
	}
	var _touches$ = getTouches(touches, this.opts, e)
	var currentOffset = this.scrollOption.currentOffset
	var opts = assign({}, this.opts, {
		_scrollDistance_: currentOffset,
		animation: false,
	})
	if (
		this.opts.type === 'line' ||
		this.opts.type === 'area' ||
		this.opts.type === 'column' ||
		this.opts.type === 'scatter' ||
		this.opts.type === 'bubble'
	) {
		var current = this.getCurrentDataIndex(e)
		var index = option.index == undefined ? current.index : option.index
		if (index > -1 || index.length > 0) {
			var seriesData = getSeriesDataItem(
				this.opts.series,
				index,
				current.group
			)
			if (seriesData.length !== 0) {
				var _getToolTipData = getToolTipData(
						seriesData,
						this.opts,
						index,
						current.group,
						this.opts.categories,
						option
					),
					textList = _getToolTipData.textList,
					offset = _getToolTipData.offset
				offset.y = _touches$.y
				opts.tooltip = {
					textList:
						option.textList !== undefined
							? option.textList
							: textList,
					offset:
						option.offset !== undefined ? option.offset : offset,
					option: option,
					index: index,
					group: current.group,
				}
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'mount') {
		var index =
			option.index == undefined
				? this.getCurrentDataIndex(e).index
				: option.index
		if (index > -1) {
			var opts = assign({}, this.opts, { animation: false })
			var seriesData = assign({}, opts._series_[index])
			var textList = [
				{
					text: option.formatter
						? option.formatter(seriesData, undefined, index, opts)
						: seriesData.name + ': ' + seriesData.data,
					color: seriesData.color,
					legendShape:
						this.opts.extra.tooltip.legendShape == 'auto'
							? seriesData.legendShape
							: this.opts.extra.tooltip.legendShape,
				},
			]
			var offset = {
				x: opts.chartData.calPoints[index].x,
				y: _touches$.y,
			}
			opts.tooltip = {
				textList: option.textList ? option.textList : textList,
				offset: option.offset !== undefined ? option.offset : offset,
				option: option,
				index: index,
			}
		}

		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'bar') {
		var current = this.getCurrentDataIndex(e)
		var index = option.index == undefined ? current.index : option.index
		if (index > -1 || index.length > 0) {
			var seriesData = getSeriesDataItem(
				this.opts.series,
				index,
				current.group
			)
			if (seriesData.length !== 0) {
				var _getToolTipData = getToolTipData(
						seriesData,
						this.opts,
						index,
						current.group,
						this.opts.categories,
						option
					),
					textList = _getToolTipData.textList,
					offset = _getToolTipData.offset
				offset.x = _touches$.x
				opts.tooltip = {
					textList:
						option.textList !== undefined
							? option.textList
							: textList,
					offset:
						option.offset !== undefined ? option.offset : offset,
					option: option,
					index: index,
				}
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'mix') {
		var current = this.getCurrentDataIndex(e)
		var index = option.index == undefined ? current.index : option.index
		if (index > -1) {
			var currentOffset = this.scrollOption.currentOffset
			var opts = assign({}, this.opts, {
				_scrollDistance_: currentOffset,
				animation: false,
			})
			var seriesData = getSeriesDataItem(this.opts.series, index)
			if (seriesData.length !== 0) {
				var _getMixToolTipData = getMixToolTipData(
						seriesData,
						this.opts,
						index,
						this.opts.categories,
						option
					),
					textList = _getMixToolTipData.textList,
					offset = _getMixToolTipData.offset
				offset.y = _touches$.y
				opts.tooltip = {
					textList: option.textList ? option.textList : textList,
					offset:
						option.offset !== undefined ? option.offset : offset,
					option: option,
					index: index,
				}
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'candle') {
		var current = this.getCurrentDataIndex(e)
		var index = option.index == undefined ? current.index : option.index
		if (index > -1) {
			var currentOffset = this.scrollOption.currentOffset
			var opts = assign({}, this.opts, {
				_scrollDistance_: currentOffset,
				animation: false,
			})
			var seriesData = getSeriesDataItem(this.opts.series, index)
			if (seriesData.length !== 0) {
				var _getToolTipData = getCandleToolTipData(
						this.opts.series[0].data,
						seriesData,
						this.opts,
						index,
						this.opts.categories,
						this.opts.extra.candle,
						option
					),
					textList = _getToolTipData.textList,
					offset = _getToolTipData.offset
				offset.y = _touches$.y
				opts.tooltip = {
					textList: option.textList ? option.textList : textList,
					offset:
						option.offset !== undefined ? option.offset : offset,
					option: option,
					index: index,
				}
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (
		this.opts.type === 'pie' ||
		this.opts.type === 'ring' ||
		this.opts.type === 'rose' ||
		this.opts.type === 'funnel'
	) {
		var index =
			option.index == undefined
				? this.getCurrentDataIndex(e)
				: option.index
		if (index > -1) {
			var opts = assign({}, this.opts, { animation: false })
			var seriesData = assign({}, opts._series_[index])
			var textList = [
				{
					text: option.formatter
						? option.formatter(seriesData, undefined, index, opts)
						: seriesData.name + ': ' + seriesData.data,
					color: seriesData.color,
					legendShape:
						this.opts.extra.tooltip.legendShape == 'auto'
							? seriesData.legendShape
							: this.opts.extra.tooltip.legendShape,
				},
			]
			var offset = {
				x: _touches$.x,
				y: _touches$.y,
			}
			opts.tooltip = {
				textList: option.textList ? option.textList : textList,
				offset: option.offset !== undefined ? option.offset : offset,
				option: option,
				index: index,
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'map') {
		var index =
			option.index == undefined
				? this.getCurrentDataIndex(e)
				: option.index
		if (index > -1) {
			var opts = assign({}, this.opts, { animation: false })
			var seriesData = assign({}, this.opts.series[index])
			seriesData.name = seriesData.properties.name
			var textList = [
				{
					text: option.formatter
						? option.formatter(
								seriesData,
								undefined,
								index,
								this.opts
						  )
						: seriesData.name,
					color: seriesData.color,
					legendShape:
						this.opts.extra.tooltip.legendShape == 'auto'
							? seriesData.legendShape
							: this.opts.extra.tooltip.legendShape,
				},
			]
			var offset = {
				x: _touches$.x,
				y: _touches$.y,
			}
			opts.tooltip = {
				textList: option.textList ? option.textList : textList,
				offset: option.offset !== undefined ? option.offset : offset,
				option: option,
				index: index,
			}
		}
		opts.updateData = false
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'word') {
		var index =
			option.index == undefined
				? this.getCurrentDataIndex(e)
				: option.index
		if (index > -1) {
			var opts = assign({}, this.opts, { animation: false })
			var seriesData = assign({}, this.opts.series[index])
			var textList = [
				{
					text: option.formatter
						? option.formatter(
								seriesData,
								undefined,
								index,
								this.opts
						  )
						: seriesData.name,
					color: seriesData.color,
					legendShape:
						this.opts.extra.tooltip.legendShape == 'auto'
							? seriesData.legendShape
							: this.opts.extra.tooltip.legendShape,
				},
			]
			var offset = {
				x: _touches$.x,
				y: _touches$.y,
			}
			opts.tooltip = {
				textList: option.textList ? option.textList : textList,
				offset: option.offset !== undefined ? option.offset : offset,
				option: option,
				index: index,
			}
		}
		opts.updateData = false
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
	if (this.opts.type === 'radar') {
		var index =
			option.index == undefined
				? this.getCurrentDataIndex(e)
				: option.index
		if (index > -1) {
			var opts = assign({}, this.opts, { animation: false })
			var seriesData = getSeriesDataItem(this.opts.series, index)
			if (seriesData.length !== 0) {
				var textList = seriesData.map((item) => {
					return {
						text: option.formatter
							? option.formatter(
									item,
									this.opts.categories[index],
									index,
									this.opts
							  )
							: item.name + ': ' + item.data,
						color: item.color,
						legendShape:
							this.opts.extra.tooltip.legendShape == 'auto'
								? item.legendShape
								: this.opts.extra.tooltip.legendShape,
					}
				})
				var offset = {
					x: _touches$.x,
					y: _touches$.y,
				}
				opts.tooltip = {
					textList: option.textList ? option.textList : textList,
					offset:
						option.offset !== undefined ? option.offset : offset,
					option: option,
					index: index,
				}
			}
		}
		drawCharts.call(this, opts.type, opts, this.config, this.context)
	}
}

uCharts.prototype.translate = function (distance) {
	this.scrollOption = {
		currentOffset: distance,
		startTouchX: distance,
		distance: 0,
		lastMoveTime: 0,
	}
	let opts = assign({}, this.opts, {
		_scrollDistance_: distance,
		animation: false,
	})
	drawCharts.call(this, this.opts.type, opts, this.config, this.context)
}

uCharts.prototype.scrollStart = function (e) {
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	var _touches$ = getTouches(touches, this.opts, e)
	if (touches && this.opts.enableScroll === true) {
		this.scrollOption.startTouchX = _touches$.x
	}
}

uCharts.prototype.scroll = function (e) {
	if (this.scrollOption.lastMoveTime === 0) {
		this.scrollOption.lastMoveTime = Date.now()
	}
	let Limit = this.opts.touchMoveLimit || 60
	let currMoveTime = Date.now()
	let duration = currMoveTime - this.scrollOption.lastMoveTime
	if (duration < Math.floor(1000 / Limit)) return
	if (this.scrollOption.startTouchX == 0) return
	this.scrollOption.lastMoveTime = currMoveTime
	var touches = null
	if (e.changedTouches) {
		touches = e.changedTouches[0]
	} else {
		touches = e.mp.changedTouches[0]
	}
	if (touches && this.opts.enableScroll === true) {
		var _touches$ = getTouches(touches, this.opts, e)
		var _distance
		_distance = _touches$.x - this.scrollOption.startTouchX
		var currentOffset = this.scrollOption.currentOffset
		var validDistance = calValidDistance(
			this,
			currentOffset + _distance,
			this.opts.chartData,
			this.config,
			this.opts
		)
		this.scrollOption.distance = _distance = validDistance - currentOffset
		var opts = assign({}, this.opts, {
			_scrollDistance_: currentOffset + _distance,
			animation: false,
		})
		this.opts = opts
		drawCharts.call(this, opts.type, opts, this.config, this.context)
		return currentOffset + _distance
	}
}

uCharts.prototype.scrollEnd = function (e) {
	if (this.opts.enableScroll === true) {
		var _scrollOption = this.scrollOption,
			currentOffset = _scrollOption.currentOffset,
			distance = _scrollOption.distance
		this.scrollOption.currentOffset = currentOffset + distance
		this.scrollOption.distance = 0
		this.scrollOption.moveCount = 0
	}
}

export default uCharts
